athola/claude-night-market
195 skills197 installs59.3k starsGitHub
Install
npx skills add https://github.com/athola/claude-night-marketSkills in this repo
1Agent Teamsagent-teams (documented as crew-roles in SKILL.md) gives solo builders a delegation framework for Claude Code–style multi-agent crews: a fixed role taxonomy, a capability matrix, and guidance on when each member type fits. Instead of giving every subagent full Bash and write access, you label workers as implementers, read-only researchers, test runners, comment-only reviewers, or architects who may plan and edit. The matrix spells out who may write files, run builds, touch git, or create tasks—reducing accidental cross-wiring during parallel feature work, test sweeps, or architecture spikes. Default behavior treats unspecified members as implementers so existing teams keep working. Use it journey-wide whenever you spin up more than one agent: scoping a validate prototype, building backend and frontend in parallel, running ship-phase review lanes, or operating incident investigation with a researcher plus implementer pair. It is meta procedural knowledge, not a task integration—pair it with your actual coding skills after roles are assigned.2installs2Rust ReviewRust Review (Async Slop module) is a detection-oriented agent skill for solo builders shipping Rust backends and CLIs. It targets the high-frequency async patterns agents default to—marking synchronous work as async, calling blocking filesystem or sleep APIs on a Tokio runtime, and leaning on tokio::spawn where a straight sequential flow is faster and easier to reason about. The skill walks pattern-by-pattern with slop versus idiomatic examples and steers you toward cargo clippy with clippy::async_yields_async as the primary signal, plus grep-based heuristics when CI clippy is not handy. It fits a pre-merge or pre-release review pass on crates that use async Rust, especially code partially authored by LLMs. Use it alongside your normal test and security checks; it does not replace full audit tools but narrows review time onto contagious async signatures and runtime-blocking calls that slip past casual diff reads.2installs3Additive Bias Defenseadditive-bias-defense is a foundational quality-contract skill for solo builders who rely on agents that tend to add files, abstractions, error handling, and config without justification. It inverts the default: the answer to adding anything is no until priority alignment and necessity are demonstrated. Use it when reviewing pull requests, planning refactors, running unbloat, or refining code so every addition— not just features—faces the same scrutiny questions. The skill documents that enforcement is voluntary via partner skills like code-refinement and unbloat rather than a leyline validator, which keeps it lightweight but requires you to invoke it explicitly in review workflows. For indie teams shipping fast with Claude Code or Cursor, it acts as a systemic guardrail against complexity creep and hallucinated fixes that modify tests to match bad changes. It is editorial guidance consumed by other skills, ideal when you want consistent review vocabulary across Ship review and Operate iteration loops.1installs4Agent ExpenditureAgent expenditure (waste-signals) is a compact reference skill for solo builders orchestrating parallel agent dispatches in Claude Code–style workflows. It names five waste categories—ghost agents that burn tokens without evidenced findings, redundant readers that re-load the same files, duplicate workers with overlapping reviews, token hogs that exceed median spend without proportional value, and related dispatch inefficiencies—and gives testable criteria rather than vague “use fewer tokens” advice. You invoke it when batching security, performance, or exploration agents and want guardrails before bills spike. It pairs with conserve:agent-expenditure as parent context and treats zero-finding low-risk scans as valid exceptions. The skill is procedural knowledge for reviewers and lead agents: compare medians by task type, require citations (paths, lines), and assign non-overlapping scopes up front. Intermediate complexity; no MCP install—paste into agent context when tuning multi-agent reviews or CI-style agent batches.1installs5Api ReviewConsistency Audit (api-review in the Night Market catalog) is an agent skill that compares your API surface to exemplar patterns and internal consistency rules so solo builders do not ship a patchwork of get_user, fetchUser, and user_get in the same crate or service. It covers naming (verb order, pluralization, abbreviations, case), parameter conventions (ordering, Option types, builders), and practical ripgrep commands to inventory functions, types, and HTTP paths. Use it when you are hardening a public HTTP or SDK API, merging modules from different authors, or preparing a review pass before launch. It is a checker workflow, not OpenAPI generation or security scanning—expect human judgment on which convention wins. Intermediate complexity assumes you can run rg in a repo and read Rust or Python idioms in the examples.1installs6Architecture Aware InitArchitecture-aware-init (paradigm selection) is an agent skill for solo and indie builders who need a defensible structural choice before implementation. It sits in the Night Market decision-support module and either routes you through the full architecture-paradigms catalog—fourteen paradigms with comparisons—or applies a compact matrix keyed to domain simplicity and engineering headcount. Use it when you have requirements sketches but no agreed pattern, when a refactor could fork into microservices versus modular monolith, or when you want the agent to name trade-offs instead of defaulting to layered CRUD. It does not generate code or diagrams; it narrows the design space so downstream build and operate skills assume the right boundaries. Pair it with archetype and integration skills once a paradigm is chosen.1installs7Architecture Diagramarchitecture-diagram is an agent skill for solo builders who need a fast, accurate system map without hand-drawing every package edge in a growing repo. It pairs a structured codebase exploration step with Mermaid generation rules—top-down for hierarchies, left-right for pipelines, subgraphs by package, and a hard cap near 15–20 nodes so diagrams stay readable in READMEs and PRs. Use it during Build when documenting new plugins or services, during Ship review when reviewers need context, or during Idea/Validate when you are still mapping an unfamiliar fork. It does not replace deep security or performance analysis; it makes relationships legible so the next implementation or refactor conversation starts aligned.1installs8Architecture Paradigm Client Serverarchitecture-paradigm-client-server is a compact architectural-pattern skill from the Claude Night Market catalog that steers solo builders through client-server versus peer-to-peer thinking before code sprawls across the stack. It triggers when you are designing systems with centralized backend services, explicit trust boundaries, or offline-first sync. The adoption path starts by separating client versus server responsibilities to avoid duplicated logic, then formalizes APIs, schemas, authentication, and capability negotiation. Version skew gets first-class treatment—feature flags, Accept headers, and semantic API versioning—so shipped mobile and web clients do not brick against a moving server. Use it while scoping a SaaS API, planning a mobile offline cache, or writing architecture notes your agent can extend into OpenAPI and deployment choices without guessing where trust ends.1installs9Architecture Paradigm Cqrs EsArchitecture Paradigm CQRS ES is an agent skill that steers solo and small-team builders through Command Query Responsibility Segregation and Event Sourcing when domain rules, compliance, or replay matter more than a single database table. It clarifies when read and write paths should split, how aggregates enforce invariants on commands, and how events become the durable history behind projections. The skill pushes back on over-engineering: plain CRUD and tiny products should not carry an event store tax. For SaaS and API backends facing uneven traffic, regulatory audit demands, or what-did-this-look-like-yesterday questions, it offers a structured adoption path instead of ad-hoc microservice sketches. Pair it with scope validation before committing to infra you cannot operate alone.1installs10Architecture Paradigm Event DrivenArchitecture Paradigm Event-Driven is an agent skill that applies event-driven asynchronous messaging so producers and consumers stay decoupled while multiple subsystems react to the same domain events. It is aimed at solo builders and small teams designing backends where request-response simplicity is insufficient—real-time pipelines, burst traffic, or ecosystems that must grow by adding subscribers rather than editing monoliths. The skill walks through when the paradigm fits, when to avoid it (simple CRUD apps or hard ACID boundaries), and concrete adoption steps: canonical event schemas with versioning, deliberate topology choice between choreography and orchestration, and ownership per event type. Use it during backend design reviews or greenfield service sketches so you do not accidentally smuggle synchronous coupling into integrations agents will later extend. It complements integration and DevOps skills once boundaries are set, but it does not replace infrastructure provisioning or testing automation.1installs11Architecture Paradigm Functional CoreArchitecture Paradigm Functional Core is an agent skill from the Claude Night Market collection that applies the Functional Core, Imperative Shell pattern when business rules are trapped inside database calls, HTTP handlers, and framework adapters. Solo builders who feel every feature test requires Docker or mocks use it to redraw boundaries: pure functions and immutable domain data at the center, and a thin shell that performs I/O. The skill documents when the paradigm helps—entangled logic, adapter churn, need for fast unit tests—and when to skip it, including performance-critical paths and teams committed to purely imperative style with no migration appetite. It supports paradigm implementation, refactoring guidance, ADR-friendly rationale, and testability improvement rather than prescribing a specific language framework. Expect intermediate effort: you inventory side effects, extract cores, and keep integration coverage honest. It pairs naturally with planning and code-review skills before large refactors. Agents receive procedural steps so refactors stay consistent across modules instead of half-applied “functional lite” patches.1installs12Architecture Paradigm HexagonalArchitecture Paradigm Hexagonal is an agent skill that applies ports-and-adapters (hexagonal) architecture so business rules live in the center and every external system connects through explicit interfaces. Solo and indie builders shipping SaaS, APIs, or CLI-backed services use it when they expect churn in databases, frameworks, or front ends but need the core domain to stay dependable. The skill walks through defining driver and driven ports, implementing adapters, and keeping infrastructure out of domain code—patterns that pay off when you add a second integration, run CI without real cloud dependencies, or refactor without rewriting business logic. It is intermediate complexity architectural guidance, not a code generator: you still implement adapters yourself, but the agent steers naming, boundaries, and test strategy. Employ it during greenfield backend design, before a major infrastructure migration, or when tests are blocked by live services. Skip it for one-file utilities with no external I/O where abstraction would only slow you down.1installs13Architecture Paradigm LayeredArchitecture Paradigm Layered is an agent skill that guides solo builders through classic n-tier layering when a single deployable app still needs readable separation between UI, business rules, and data access. It fits moderate systems where compliance or team handoffs benefit from familiar boundaries but independent service scaling is not yet required. The skill contrasts employ versus avoid scenarios—skip it when you need independent deploy cycles or heavy cross-cutting domain choreography. Deliverables emphasize adoption steps, technology pointers, and risk mitigations so the agent produces architecture notes you can drop into ADRs or onboarding docs. Complexity is rated low with a fast model hint, making it a lightweight checkpoint during Build before you commit folder structure and dependency rules across the codebase.1installs14Architecture Paradigm MicrokernelArchitecture Paradigm Microkernel is an agent skill that applies the microkernel (plugin) pattern: a small, stable core that exposes a clear extension contract while features live in plugins. Solo and indie builders use it when designing SaaS platforms, agent marketplaces, ingestion pipelines, or tools where customers or partners add capabilities without forking the product. The skill contrasts when to employ the paradigm—extensible systems, customer-specific customizations, critical core stability—with when not to, such as monoliths with no plugin story. It walks through adoption steps including delineating core responsibilities (scheduling, lifecycle, primitives, messaging) and specifying how plugins register, communicate, and fail. It does not replace implementation work; it gives structured architectural guidance so agents and humans align on boundaries before coding. Pair it with API design and security review when plugins run untrusted code.1installs15Architecture Paradigm Microservicesarchitecture-paradigm-microservices is a library-style agent skill from the night-market catalog that applies the microservices paradigm for independent deployment and per-service scaling. It is written for builders and tech leads who must decide whether organizational autonomy and heterogeneous scaling needs justify the operational tax of distributed systems. The skill frames when to employ the pattern—team autonomy, bounded contexts with different scale or stack needs, and serious DevOps/SRE investment—and when to avoid it, including undersized teams and weak platform maturity. Adoption steps, deliverables, technology guidance, and risk mitigations turn the pattern into an actionable plan rather than a buzzword. For solo and indie builders on Prism, it is most valuable as a scope gate: validate whether you are accidentally choosing microservices for resume-driven architecture, or whether release independence truly matters. Pair the output with service-boundary docs and gateway/observability plans before backend implementation accelerates.1installs16Architecture Paradigm Modular MonolithArchitecture Paradigm: Modular Monolith is a Claude Night Market architectural-pattern skill that helps agents apply a modern monolith style—distinct modules with hard internal edges—so solo builders and small teams get microservice-like clarity without running a fleet of services. Invoke it when you are scoping a SaaS or API codebase that has grown past a single folder but does not yet justify Kubernetes, service meshes, or cross-network transactions. The skill walks through when autonomy and dependency discipline matter, when module overhead is wasted on toy apps, and a staged adoption checklist rooted in domain-driven bounded contexts. Agents can propose package layout, visibility rules, and dependency policies that keep teams—or future you—working in parallel. It complements implementation work in Build and ongoing refactors in Operate, but its primary value is deciding and documenting the paradigm before implementation sprawls. Complexity is medium: you need enough system design literacy to name modules honestly and enforce boundaries in code review.1installs17Architecture Paradigm PipelineArchitecture Paradigm Pipeline applies the pipes-and-filters pattern so solo builders design systems where data moves through a fixed chain of discrete transformations. The skill from Claude Night Market activates when work looks like ETL jobs, streaming analytics, or CI/CD pipelines that must reuse stages independently or scale bottlenecks without rewiring everything. It prescribes adoption steps: define each filter around one transformation with clear schemas, connect stages through pipes that buffer and back-pressure, keep filters stateless with external state at boundaries, and isolate failures between stages. That framing helps one-person teams avoid monolithic scripts that are hard to test or replace. Use it while sketching backend flows during Build, when hardening delivery graphs during Ship, or when reasoning about staged processing in Operate. It is architectural guidance—not a deploy tool—so you still pick concrete queues, streams, and frameworks afterward. Estimated complexity is medium, suited to agents with standard model hints when you need a repeatable pattern vocabulary.1installs18Architecture ParadigmsArchitecture Paradigms is a meta-routing agent skill for solo and indie builders who need to choose how a new system should be structured without reading a dozen pattern guides upfront. You invoke it when starting a greenfield service, comparing trade-offs between monolith and services, or preparing an architecture decision record before your agent writes implementation plans. The skill does not implement a single pattern; it runs a structured selection flow—a scenario router, a three-step workflow, and explicit exit criteria—then hands you off to the matching paradigm skill in the same night-market stack (functional core, hexagonal, CQRS/ES, event-driven, layered, modular monolith, microkernel, microservices, and others). That makes it especially useful on Validate when scope is still fluid and on Build when backend shape locks integrations and deployment. Intermediate complexity: you should already know your domain constraints and team size, but you do not need to be a staff architect. Optimized for Claude Code-style agents that can chain skills by dependency rather than one-shot chat advice.1installs19Architecture Paradigm ServerlessArchitecture Paradigm: Serverless teaches agents how to apply functions-as-a-service for workloads that spike unpredictably and fit an event-driven mental model—HTTP hooks, queues, schedules—while pushing persistent state to managed databases and message systems. Solo builders evaluating a webhook processor, lightweight API, or automation backend can use it to avoid renting always-on servers when executions are sparse, provided they accept cold starts and strict runtime ceilings. The skill contrasts bursty, ops-light scenarios against poor fits such as long-lived connections, minutes-long jobs, or heavy in-function caching. Adoption steps emphasize small stateless handlers, external stores, and idempotent retries so duplicated events do not corrupt data. It spans Validate when picking cloud shape, Build when wiring triggers and IAM, and Ship when reasoning about perf and cost caps. Medium complexity: you need basic cloud literacy and honesty about latency SLOs before committing the whole product to FaaS.1installs20Architecture Paradigm Service BasedArchitecture Paradigm Service-Based is a concise agent skill that teaches solo builders and growing teams when coarse-grained services beat both a tangled monolith and a microservices explosion. It applies when multiple squads need to ship components on different cadences but ERP-scale or legacy constraints force a shared database. The skill walks adoption: bundle related business capabilities into a small set of owned services, publish formal contracts with OpenAPI or AsyncAPI, and attach realistic SLAs so partner teams know what stability to expect. It also states clear anti-patterns—skip it for tiny single-team codebases or systems where every cross-service hop blows latency budgets. Estimated guidance volume is medium complexity (~700 tokens of pattern content), making it a fast architecture checkpoint before you commit to extraction work or pitch deployment independence to stakeholders.1installs21Architecture Paradigm Space Basedarchitecture-paradigm-space-based is an agent skill that teaches the space-based architecture paradigm for high-traffic, stateful systems that cannot scale on a single database node. Solo and indie builders shipping SaaS or API backends use it when traffic or state volume overwhelms one node, when latency needs in-memory data grids near compute, or when they need linear scale by partitioning work across replicated caches. The skill contrasts when to employ the paradigm versus when simpler caching or consistency-first designs are better, then walks through workload partitioning, grid technology and replication choices, eviction policies, and coordinating durable writes. It is editorial architectural guidance—not an installer or IaC generator—so you still pick concrete products and validate trade-offs for your stack. Complexity is advanced because it assumes you are already hitting scale limits and can reason about availability versus consistency.1installs22Architecture ReviewADR Audit is an agent skill module that teaches detailed Architecture Decision Record discovery, validation, and governance workflows for indie and solo builders maintaining real products. It maps common ADR folder layouts, shell search patterns for markdown decision files, and a checklist of mandatory sections so agents do not approve hollow or orphaned documents. Status lifecycle rules mirror mature engineering practice: proposals graduate through review to acceptance, invalidation happens only via supersession with explicit pointers, and history stays append-only. The skill fits when you are consolidating wiki sprawl, onboarding a contractor, or preparing a security or architecture review where undocumented choices create risk. It pairs with broader architecture-review parent skills but stands alone as procedural knowledge for ADR hygiene. Complexity is intermediate because it expects familiarity with repos, markdown docs, and decision-making tradeoffs rather than greenfield UI work.1installs23Assisted MasteryAssisted Mastery is a journey-wide agent skill from the Claude Night Market lineage that teaches solo builders how to pair with coding agents without outsourcing judgment permanently. It contrasts Explain mode—where the agent narrates reasoning and scaffolding while the human writes consequential code—with Produce mode for boilerplate and reversible work. Selection flows from task risk (via leyline:risk-classification) and from whether you optimize for throughput or long-term skill. High-stakes areas force Explain even when you want speed. The fade principle gradually reduces hand-holding so assistance tiers do not freeze at maximum automation. State the mode explicitly before work begins; otherwise produce becomes the silent default and learning value collapses. Use this skill whenever you start a non-trivial agent session across validate prototypes, build features, ship reviews, or operate fixes—not only on greenfield coding.1installs24Authentication PatternsAuthentication-patterns is an agent skill from the Claude Night Market / Leyline line that shows how to integrate interactive authentication into existing bash workflows. Solo builders hitting GitHub, or similar services, from custom commands often copy-paste auth checks that exit with opaque errors; this skill replaces that with sourced interactive_auth modules and ensure_auth gates. Examples contrast the old manual gh auth status pattern with cached interactive auth, then apply it to PR review and issue creation flows that call gh and the GitHub API. Benefits called out include user prompts when credentials are missing, short-lived status caching to avoid repeated checks, day-long session persistence for local dev, and CI compatibility when tokens are injected. The pattern is meant to be copied at the top of any workflow that needs network-backed CLIs so agents consistently authenticate before fetching PRs, comments, or creating issues.1installs25Blast RadiusBlast Radius is an agent skill entrypoint for solo and indie builders who want merge confidence without flying blind on diffs. Before merging, it shows what changed (git diff --stat), then traces blast radius through a code knowledge graph when the gauntlet plugin is available—mapping affected nodes and surfacing risk scoring aligned with review workflows. Without gauntlet, it does not stop: it falls back to manual impact analysis from the diff and repository search, and can layer sem for JSON impact traces when installed. That makes it practical on real repos where graph tooling may not be set up yet, while still nudging you toward graph builds for richer signal. Use it when a PR touches shared modules, refactors, or paths with thin tests and you need a structured picture of downstream callers and coverage gaps—not a substitute for CI, but a focused pre-merge sanity pass for Claude Code-style agents.1installs26Bloat DetectorBloat Detector is a Claude Night Market conserve module aimed at solo builders who ship fast with agents and need an objective pass for AI-generated debt. It targets patterns that differ from classic legacy bloat: repeated logic blocks instead of shared utilities, enormous insertion commits without matching tests, and other vibe-coding tells tied to agent-assisted workflows. The module documents runnable checks—duplicate detection scripts, git log heuristics, and grep-based signature clustering—with recommended actions such as refactor versus investigate. It frames why the problem matters using published trends on copy-paste growth and collapsing refactor rates so you can justify cleanup to yourself or stakeholders. Run it when a feature branch balloons overnight or before a release candidate merge; pair results with human judgment because confidence scores are heuristics, not verdicts. It complements generic linters by focusing on how models tend to duplicate and over-insert rather than syntax alone.1installs27Browser Recordingbrowser-recording is an agent skill for solo builders who want Playwright specs executed with session video turned on. It documents how to define a minimal defineConfig with video: 'on' and outputDir under ./test-results, then scale to a full recording profile with explicit video size, viewport, headless defaults, slowMo for visible steps, contextOptions.recordVideo, retries disabled, and a single worker so captures stay deterministic. You use it when UI or E2E tests need visual proof for CI failures, stakeholder review, or agent-driven regression checks—not when you only need trace logs or screenshots. For Prism’s ship journey, it sits beside other QA skills as a concrete integration pattern: configure once, run specs/demo.spec.ts or filtered tests, and collect artifacts under test-results and optional videos subfolders. Intermediate complexity assumes you already have Playwright installed and spec files; the skill does not replace test authoring, only reliable recorded execution.1installs28Bug ReviewBug-review is a defect-documentation agent skill that forces systematic identification instead of vague “something broke” notes. It walks you through capturing precise locations—file path, line number, containing function, and a short context snippet—so fixes and handoffs stay reproducible. A fixed severity table ties each issue to business impact and expected response time, from immediate Critical (crash, data loss, security) through backlog Low edge cases. Root-cause categories group logic mistakes, API misuse, concurrency failures, and resource leaks so patterns show up across sprints. Progressive loading keeps token use reasonable while still pairing with proof-of-work style verification from its dependency chain. Solo builders shipping agents, CLIs, or SaaS backends use it during PR review, pre-release sweeps, and post-incident writeups when you need audit-ready bug lists—not brainstorming fixes.1installs29Call ChainCall Chain is an agent skill for solo builders who need to see how execution actually moves through their repo—not just a single file. It targets a function name or entry point, then uses the gauntlet plugin’s graph_query tool to trace flows up to depth 15, apply criticality scoring, and render Mermaid charts from the code knowledge graph. When gauntlet is not installed, the skill explicitly falls back to ripgrep or grep to reconstruct call trees from import and invocation patterns so you are never blocked from a diagram. It fits greenfield navigation, pre-refactor reconnaissance, and understanding blast radius before changing shared utilities. You run it when a symptom points at one function but the real behavior spans layers. Intermediate complexity: you need either a built graph.db or comfort reading search hits into a manual tree.1installs30CatchupCatchup (document-analysis-patterns) teaches an agent how to reconstruct what changed while you were away from a project thread. Instead of rereading entire meeting archives or ticket walls, the skill establishes a baseline date or version, enumerates deltas—completed work, new backlog items, priority moves, revised specs—and surfaces insights such as consensus shifts, schedule risk, and scope creep. Solo builders use it when returning from a break, onboarding an agent mid-sprint, or syncing before a planning session. It complements human note-taking systems rather than replacing them: the agent applies consistent lenses for meetings, issue trackers, and RFC revisions. Placement is multi-phase because the same delta methodology applies during Build PM, Grow support triage, and Operate iteration reviews, even though Prism lists Build/PM as the primary shelf.1installs31ChallengeChallenge is a Claude Night Market skill that presents adaptive Gauntlet questions drawn from a project knowledge base to test how well a developer understands the codebase. It reads gauntlet state, optionally scores a pending answer, generates a weighted challenge, records pass/partial/fail outcomes, and can emit pre-commit pass tokens when used as a gate. Solo maintainers and tiny teams can use it to turn tribal knowledge in `.gauntlet/knowledge.json` into repeatable onboarding drills instead of static README quizzes. The skill includes optional in-loop provider setup for Claude Code sessions. It is specialized agent-tooling for repos that already adopt the Gauntlet workflow—not a general-purpose interview prep or production monitoring skill.1installs32Class Diagramclass-diagram is an agent skill from the Claude Night Market cartograph family that produces Mermaid class diagrams from a structural model of your codebase. Solo builders use it when they need to see how types relate—inheritance versus composition—without manually drawing every public method. The workflow is deliberate: first a codebase-explorer agent returns classes, protocols, parents, and composed types for a scoped area, then you transform that model into valid Mermaid with stereotypes and relationship arrows. It fits backend and full-stack modules where onboarding, design reviews, or README updates need a single visual truth. Because it limits to roughly a dozen classes, it works best for one package or feature slice rather than an entire monorepo at once.1installs33Clear ContextClear-context (session state schema) is an agent skill that specifies how solo builders format session state checkpoint markdown so Claude Code and similar agents can hand off cleanly when context fills up or work pauses at task boundaries. It mandates a state_version field, a standard header (Generated time and Reason), and four core sections that tell the next agent what mode you were in, what you were trying to do, what already happened, and what to do next. Optional blocks capture decisions, touched files, open todos, and deduplication task IDs. Because long autonomous sessions are normal for indie builders shipping with agents, a stable schema reduces garbled resumes and repeated work. Use it whenever you rely on checkpoint files or continuation prompts rather than stuffing everything back into chat.1installs34Code CommunitiesCode Community Detection is an agent skill that turns your repository into actionable architecture insight by finding natural code clusters and coupling boundaries. Solo builders use it when a monolith feels tangled, before extracting a package, or when planning which folders should not import each other. With the gauntlet plugin, the skill runs community detection on the built code graph; without gauntlet it still delivers value by grouping files by directory and ranking cross-directory imports. Outputs orient refactoring: which areas move together, where boundaries are violated, and what to decouple first. It pairs well with graph-aware skills in the same night-market family and keeps analysis local via shell commands rather than shipping code to a third party.1installs35Code Quality Principlescode-quality-principles is a compact always-on agent skill from the Claude Night Market collection that steers solo builders toward KISS, YAGNI, and SOLID when refactoring or reviewing code for over-engineering. It is not a linter replacement; it supplies decision tables, anti-pattern examples, and readable alternatives in languages such as Python and Rust so coding agents prefer obvious control flow over clever abstractions. Use it whenever you want maintainability guardrails during Ship review or mid-Build cleanup, and skip it for one-off migrations or hotspots where documented performance tradeoffs trump readability. Because alwaysApply is set, the skill nudges everyday edits without a separate invoke ritual—ideal for Cursor or Claude Code sessions where scope creep is the main risk. The guidance fits SaaS backends, CLIs, and APIs where a single founder still owns every layer.1installs36Code RefinementCode Refinement (algorithm-efficiency module) is an agent skill that hunts algorithmic inefficiencies at the function and loop level—nested iterations, redundant sorting, and similar patterns that turn linear work into quadratic cost. Solo and indie builders shipping SaaS, APIs, or CLIs use it when a feature works but feels slow, or when review time should include complexity passes without hiring a performance consultant. The skill documents concrete anti-patterns and better data structures, and points to shell-friendly grep workflows to surface suspicious nested loops in Python trees. It deliberately stays out of distributed architecture and ORM query optimization so agents stay focused on fixes a single developer can land in one PR. Pair it with your normal ship-phase testing and review; outcomes are clearer Big-O reasoning and copy-paste refactor suggestions your coding agent can implement immediately.1installs37Code SearchCode Search is a library-role agent skill in the Claude Night Market / Tome stack that finds existing implementations and patterns on GitHub during research. Solo builders use it when they need prior art before writing custom integrations, choosing a library, or validating that an approach already exists in open source. The workflow builds GitHub-oriented search queries, executes them through WebSearch, optionally enriches via the GitHub API, ranks results, and emits structured Finding objects for downstream synthesis. It is narrowly scoped: it does not search your local tree and it does not replace academic literature search. Estimated footprint is small (~200 tokens in metadata), with a standard model hint. Pair it with broader research orchestration when exploring competitors or technical feasibility in early journey phases.1installs38Commit MessagesCommit messages is an agent skill from the Claude Night Market collection that turns staged git changes into conventional commit messages suited for solo repos and small teams. It defines a repeatable ritual: pull status and cached diff in parallel, optionally enrich with sem entity names instead of raw hunk guessing, classify type and scope, then draft an imperative subject plus wrapped body and footers. That saves time when you ship fast with Claude Code or Cursor and do not want vague subjects like "fix stuff". It is intentionally not full PR preparation— the SKILL.md directs you to sanctum:pr-prep for that—and not for amend workflows you should do directly in git. Complexity is beginner-friendly with an estimated ~350 token footprint and fast model hint. Use whenever you have staged changes and need a message; it spans Build daily work and Ship review moments when commits must read clearly in changelog automation.1installs39Compression StrategyCompression Strategy (Log Debugging Hygiene) is an agent skill that teaches a disciplined order of operations when log output is too large for an AI coding session. Solo and indie builders shipping with Claude Code hit this constantly: a CI failure, hook trace, or server dump can push context past 50% utilization in one paste. The skill argues compression should be the last lever, not the first, and walks through Tier 1 filtering at the source (tail, grep, jq, time windows) for roughly 90–99% byte reduction, Tier 2 minimization, and only then optional compression—with token measurement baked in via required todos. It fits anyone debugging agents, pipelines, or production services who needs forensic lines without sacrificing the rest of the conversation. Skip it when the paste is already small or when every line must remain verbatim for a formal report.1installs40Computer ControlComputer Control is an agent skill for athola’s phantom stack that connects Claude’s Computer Use API to desktop environments through screenshots and mouse or keyboard actions. Solo builders reach for it when a vendor portal, legacy desktop app, or visual-only flow blocks normal scripting—filling forms, walking menus, or recording tutorial steps that need pixel-level confirmation. The skill is deliberately opt-in because it captures the display and drives cross-process input; inclusive-defaults treat that as a TRUE exception that must never run silently. Architecturally, display tooling executes OS actions, the agent loop mediates API rounds, and the CLI surfaces task runs and environment checks. Intermediate complexity: you need a Linux-friendly display setup (xdotool/scrot path), comfort delegating GUI steps to an agent, and judgment to fall back to Playwright when the target is a modern browser tab alone.1installs41Content Sanitizationcontent-sanitization is an agent skill that defines how to treat external text before it enters skills, hooks, or model context on Claude Night Market–style setups. Indie builders shipping agents that pull GitHub Issues, PRs, discussions, or web pages need a repeatable trust model instead of piping raw HTML and pseudo-instructions into the prompt. The skill classifies sources into trusted, semi-trusted, and untrusted tiers and applies a short checklist—size limits and removal of dangerous system tags—so automation stays useful without becoming a prompt-injection vector. It complements local-only code review skills by covering the boundary where the repo ends and the internet begins. Use it while building agent-tooling integrations and again before production hooks run unattended; it does not replace full malware scanning or secrets scanning of attachments.1installs42Context Mapcontext-map is an agent skill that generates a compressed project context map so solo builders and their assistants avoid expensive Read and Grep discovery on every session. The SKILL.md positions it at session start, before feature work, and when exploring an unfamiliar codebase—exactly when token waste hurts most on Claude Code, Cursor, or Codex. It pre-compiles structure, multi-ecosystem dependencies, entry points, import relationships, blast-radius hot files, HTTP routes, env var usage, and middleware hints into a single map developers can skim before touching code. That turns vague “where does auth live?” questions into guided entry points and reduces the chance you refactor a highly imported module by accident. Complexity is intentionally low: no production deploy steps, just exploration hygiene. Pair it with implementation or review skills once the map highlights the files that matter.1installs43Context Optimizationcontext-optimization (Belief Clarity module) is a conservation-layer agent skill that stops you from shipping truncated chat history or session-state files that look tidy but cannot answer what was done and what is still missing. Solo builders running long Claude Code, Cursor, or Codex sessions hit context limits constantly; without this gate, continuation agents confidently execute the wrong next step because intermediate summaries dropped constraints. The skill implements two anchor questions—a progress probe and a gap probe—against any draft memory or compressed context, and blocks handoff when answers are vague. Use it journey-wide whenever you compress, summarize, or write session-state.md before clear-context workflows. It is intermediate complexity because you must interpret qualitative failures and expand the summary rather than expecting automatic metrics. Outcome is safer multi-step agent work with fewer belief-deviation loops across Build, Ship, and Operate debugging marathons.1installs44Cpu Gpu PerformanceCPU/GPU Performance is a journey-wide discipline skill from Claude Night Market for solo builders who routinely compile, train models, or run long tests on laptops or rented GPUs. It forces a repeatable five-step ritual—baseline, scope, instrumentation, throttling, and logging—before operations that could saturate cores or VRAM. The skill pairs with token-conservation at session open and before retrying previously expensive failing commands. It is not for trivial edits or single-file tweaks. Agents document decisions in TodoWrite so you can see why a job was sequenced or throttled instead of blindly re-running a OOM crash. The outcome is predictable resource usage during Build shipping prep and Operate iteration, which matters when one person owns hardware bills and incident recovery.1installs45CurateCurate is an agent skill from Claude Night Market for solo builders maintaining a gauntlet-style knowledge base around a complex module tree. When code cannot explain why a rule exists—org history, failure modes, or ‘never touch this’ boundaries—you run curate to interview the author (or yourself), distill a concept plus rationale, and emit a YAML annotation file under `.gauntlet/annotations/<slug>.yaml` that future agent challenges automatically include. It is lightweight documentation workflow, not a linter: you still need a real module target and honest context. Use during active build when onboarding your future self, before handoff, or when friction-detector surfaces repeated mistakes that need a human ‘why’ on record. Skip when the answer already lives in README or ADRs and duplicating would confuse retrieval. Standard model hint keeps cost predictable for many small annotations across a growing agent repo.1installs46Damage ControlDamage Control (context-overflow) is an agent skill module that teaches procedures for reconstructing decision context when the context window is exhausted mid-session. Solo and indie builders running long Claude Code, Cursor, or Codex sessions install it for the silent failure mode where the agent continues but cannot see earlier reasoning, tool results, or user constraints. The skill applies whenever symptoms appear—references to missing decisions, duplicated implementation, or outputs that disagree with the first half of the session—not only after a hard crash. It prescribes stopping immediately, anchoring known state to durable artifacts (especially the task list), and continuing without replaying lost context. That makes it journey-wide procedural knowledge usable during Build integrations, Ship review marathons, or Operate debugging, whenever window pressure erodes reliability.1installs47Data FlowData Flow is an agent skill that produces Mermaid sequence diagrams describing how data and control move between components in your codebase. It is aimed at solo and indie builders who need clear request-path documentation for APIs, CLIs, or agent stacks without spending hours in a diagramming tool. Invoke it when you are tracing an end-to-end request, documenting a transformation pipeline, or mapping an API call chain for teammates or future you. The workflow dispatches a codebase explorer to build a structural model focused on calls and transformations, then converts that model into sequenceDiagram syntax with opinionated limits (participants as modules, conditional branches, transformation notes). The result is paste-ready documentation you can drop into READMEs, ADRs, or onboarding notes—especially valuable when agents have generated code you do not yet fully mental-model.1installs48Decision JournalDecision Journal is a journey-wide agent skill that standardizes how solo builders record tradeoffs and lessons beside the code. AI-assisted sessions often produce artifacts without preserving the reasoning: what you picked, what you rejected, and what rework taught you. This skill contract points workflows at two append-only logs under `docs/`—tradeoffs for decisions and sacrifices, lessons-learned for failed approaches framed without blame—and explains when to reference a formal ADR instead of duplicating it. Invoke it right after a meaningful choice, a blocker, or when you are building or validating a consumer hook that writes to those files; skip it for greenfield scaffolding (that belongs to project-init) and skip turning every architecture call into a journal dump when `docs/adr/` is the right home. It is convention-driven rather than a hard runtime dependency, so teams without the full Attune stack still benefit from the file discipline. For Prism’s audience, it is lightweight operating memory across Validate through Operate: you keep agents honest and your future self unblocked without a heavyweight PM suite.1installs49Decisive ActionDecisive Action is a journey-wide agent skill that teaches when to ask clarifying questions versus moving forward autonomously. It is aimed at solo and indie builders who lose time when agents over-clarify obvious tasks or under-clarify risky ones. The skill encodes a decision framework: proceed when intent is clear and reversible; pause when destruction, security, ambiguous tradeoffs, data migration, or breaking changes could make a wrong guess expensive. A short checklist ties question-asking to estimated misinterpretation risk and correction cost. Because it is marked alwaysApply in the source skill, it is meant to ride along during Idea scoping, Validate prototypes, Build and Ship edits, and Operate fixes—not only one phase. Use it to make agents feel more like a decisive teammate while keeping guardrails on irreversible operations.1installs50Deferred CaptureDeferred-capture is a meta specification skill for the athola/claude-night-market plugin ecosystem. It documents the shared contract every deferred-capture wrapper must follow so solo builders and small teams do not fork incompatible CLIs, labels, or issue titles when sessions defer follow-up work to GitHub. Use it when you are authoring a new plugin wrapper, validating an existing script against the standard, or extending the contract with additional source labels or template fields. The skill spells out required and optional arguments, session ID sourcing from CLAUDE_SESSION_ID, artifact paths, and dry-run JSON behavior without executing capture itself. That separation keeps agent planning skills honest: deferred items still land as uniform issues while explicit runtime paths stay in plugin scripts. Intermediate plugin maintainers get a checklist-aligned reference that pairs with ship-phase review when you audit wrappers before release.1installs51Delegation Coredelegation-core (documented as cost-estimation under the conjure delegation framework) gives solo and indie builders concrete math for external LLM delegation: compare Gemini and Qwen input/output pricing, plug in expected token volumes, and judge whether time saved and quality gains justify spend. It pairs operational dependencies—quota management and usage logging—so estimates are not theoretical. Use it when you are about to fan out repetitive codebase tasks, large summarization jobs, or bulk generation to a cheaper model and need a consistent rule instead of guessing. The worked examples span low-cost grep-style delegations through medium architecture passes to high-cost full-repo reviews. It does not replace provider dashboards or your own rate limits; it standardizes when to delegate and how to think about marginal cost per task.1installs52Dependency GraphDependency graph is an agent skill that turns import relationships into a Mermaid flowchart so solo builders see coupling before they cut code. You start by dispatching a codebase explorer agent to collect internal and external imports across a chosen scope, then translate that structural model into flowchart LR syntax: nodes as modules or packages, edges from dependent to dependency, subgraphs by package, and visual cues for optional versus critical links. It answers planning questions—what depends on what, where cycles hide, and what breaks if a file changes—without running a separate proprietary diagramming tool. Intermediate users refactoring monoliths, plugin systems, or microservice boundaries benefit most. Output is paste-ready Mermaid for docs or PRs. It complements manual code review by making blast radius visible early in Build and again during Ship review when assessing refactor risk.1installs53Dependency VerificationDependency verification is a registry-backed guard for AI-driven package installs across PyPI, npm, and crates.io. Solo builders and small teams use it when coding agents run pip, npm, or cargo add commands and you need confidence the name resolves to a real artifact—not a model hallucination or typosquat. The hook labels each target as exists, nonexistent, or unverified, blocking hard failures only when the registry returns 404 and strict mode is on, while network timeouts and rate limits warn without failing closed. Popular packages are matched offline first to keep everyday workflows fast. For air-gapped or sandboxed agents, you can disable live lookups and lean on edit-distance signals against a bundled popular set. It pairs naturally with agent hooks in Claude Code–style setups where shell installs are common.1installs54Diff AnalysisGit Diff Patterns is a tool-integration companion to imbue:diff-analysis that teaches agents exact git commands for baseline scoping, change-type isolation, and evidence-backed review. Solo and indie builders shipping with Claude Code, Cursor, or Codex use it when a PR or branch diff is too large to eyeball—you define the comparison window, slice additions versus modifications versus deletions, and feed structured findings into semantic categorization and risk assessment. The skill explicitly sequences Sanctum’s git-workspace-review ahead of imbue-specific analysis so repository context (pwd, branch, staged versus unstaged, statistics) is gathered before interpretation. It fits agent workflows that treat review as a repeatable ritual rather than ad-hoc git log scrolling, and it stays anchored in standard git CLI patterns without inventing custom tooling.1installs55DigDig is a refinement skill for the Claude Night Market Tome research stack. Solo and indie builders use it when a `/tome:research` pass returned useful breadth but one subtopic or source channel needs more depth—competitor papers, a single distribution angle, or a narrower keyword slice. The workflow loads the latest session, runs a focused search, merges and re-ranks new hits into the existing report, and surfaces deltas to you. It does not replace starting research or final synthesis; those stay on `/tome:research` and `/tome:synthesize`. Fits agents that already maintain session state and multi-channel search. Intermediate complexity: you need an active session and sane channel names from the first pass.1installs56Digital Garden CultivatorDigital garden cultivator is a journey-wide agent skill for solo builders who treat notes as a living publication, not a archive folder. It guides how to structure a digital garden so each note sits in a navigable graph: direct links for obvious topics, contextual links when the relationship needs a sentence, hub nodes that organize clusters like API design, and bridge links that connect insights across domains. The skill emphasizes bidirectional linking, explaining why a link exists, avoiding orphan pages, and keeping outbound density in a readable 3–7 range with periodic pruning of stale edges. Complexity is beginner-friendly and estimated token footprint is small, making it easy to invoke during research dumps, writing sessions, or weekly garden reviews. It depends on the broader digital-garden-cultivator ecosystem and complements linking-patterns for tactical bidirectional strategies.1installs57DiscourseDiscourse is a Night Market library skill that scans Hacker News, Lobsters, Reddit, and selected tech blogs for real-world opinions and war stories about a technology or approach. Solo builders invoke it when spreadsheets of stars and docs are not enough—they need how practitioners actually felt after shipping, migrating, or regretting a choice. The workflow standardizes per-channel query construction, API or search execution, parsing into Finding objects, and merging results with clear attribution. It is deliberately narrow compared to paper search or code search, which keeps agent runs fast and on-topic. Use it during idea exploration, validation spikes, and build-phase integration picks when community sentiment should inform risk. It assumes network access and respectful API usage rather than bulk scraping without limits.1installs58Doc Consolidationdoc-consolidation gives solo builders a deterministic module for spotting markdown that should merge into real documentation instead of cluttering the repository root. It ranks detection signals: untracked .md outside blessed folders, shouty report-style filenames, and LLM-typical headings in the first hundred lines—with carve-outs for README, LICENSE, and CHANGELOG. The workflow is git-aware so agent sessions that spawn API_REVIEW_REPORT.md or MIGRATION_ANALYSIS.md get flagged early. Multi-phase value shows up whenever you tidy after a build spike, pre-launch doc pass, or post-incident write-ups. Teams using Claude night-market style agent packs can run the same rules before commit to keep skills/, commands/, and docs/ authoritative while transient analysis files get consolidated or archived.1installs59Doc Generatordoc-generator is an agent skill module that encodes documentation generation guidelines for solo and indie builders who want agent-written docs to pass as human-quality. It lives in the writing-quality category and gives concrete rules for openings, section sizing, paragraph structure, and 80-character line wrapping so READMEs, guides, and API references stay scannable in git and on phones. Use it whenever your coding agent drafts or refreshes project documentation—not as a one-off formatter but as procedural knowledge that steers tone and structure across the journey. The skill does not invent install counts or product facts; it shapes how facts are presented. Pair it with your repo’s real commands and configs so highlights stay truthful. It matters for Prism audiences because discoverability and trust often hinge on the first page of docs, and bloated AI intros hurt both SEO snippets and developer confidence.1installs60Doc ImporterDocument Importer is an agent skill for solo builders who receive specs, decks, spreadsheets, or exports as binary files and need them inside the repo as editable markdown. Use it when someone hands you a DOCX, PPTX, XLSX, PDF, or HTML path or URL and you want project documentation you can rewrite, diff, or feed into other scribe and leyline skills. The workflow starts by confirming the source exists or the URL is reachable, then applies the document-conversion protocol: construct a URI, try markitdown for best fidelity, and fall back to native tools when MCP is unavailable. It deliberately avoids overlapping jobs—academic papers go to tome:papers, web articles to memory-palace:knowledge-intake, and markdown already in tree goes straight to scribe remediation. Estimated footprint is lightweight (basic complexity, fast model hint), which suits indie operators batching client deliverables or internal wikis without standing up a separate ETL pipeline. Install it when ingestion is the bottleneck, not when you only need greenfield doc generation from scratch.1installs61Document Conversiondocument-conversion (fallback-tiers module) is the operational core of athola’s Claude Night Market skill for turning office and web documents into sanitized markdown your agent can reason over. Solo builders use it whenever specs, papers, or articles live outside the repo as PDFs or HTML and you need reliable text without manually copy-pasting. The workflow is deliberately two-tier: try MCP markitdown with constructed URIs, and only if the server is missing or the file fails conversion, fall back to native agent tools—Read on PDFs in 20-page chunks or WebFetch for HTML—then run content sanitization on the result. That design fits indie workflows where MCP may be offline on a laptop but you still want one skill to gate quality. Expect degraded structure on fallback paths; plan chunking for long PDFs and accept that scanned pages may yield empty text until OCR exists elsewhere.1installs62Doc UpdatesDoc Updates is the Accuracy Scanning Module inside Claude Night Market’s documentation pipeline. It exists so solo maintainers of multi-plugin agent repos do not ship READMEs and API overviews that lie about versions, plugin totals, or per-plugin skill and command counts. Before preview, the skill compares documentation patterns against filesystem truth: iterating plugins/*/.claude-plugin/plugin.json for versions, counting valid plugin directories, and listing skills and commands per plugin when tables claim inventory. Findings surface as markdown warning tables pairing file, claimed value, actual value, and a concrete update action. The workflow is deliberately mechanical—bash and jq samples are part of the spec—so agents repeat the same validations every release. It complements human editing rather than rewriting docs automatically, which keeps you in control while catching drift early in build and pre-ship review cycles.1installs63Do Issuedo-issue is the completion leg of Claude Night Market’s issue automation: after parallel or upstream phases, it runs dependent implementation tasks one at a time using structured Task-tool prompts, then triggers a detailed multi-issue code review subagent. Solo builders use it when several linked GitHub issues must land together without branch sprawl. The flow mirrors subagent-driven development—implement, review after each sequential step, then a final gate before PR. Built-in gh CLI examples add completion comments and optional closes referencing the fixing commit. The pre-PR consolidation check forces a single branch audit so automated fixes do not scatter across worktrees. Pair it with earlier night-market phases that scope and split issues; this skill assumes tasks and acceptance criteria already exist.1installs64Dora Metricsdora-metrics is an agent skill from Claude Night Market that reframes classic DORA measurements for AI-assisted delivery. Solo builders and small teams already track deployments and incidents; this module explains what to watch when agents join the pipeline—splitting change failure rate by label, comparing lead time across adoption windows, sanity-checking time to restore after agent hotfixes, and capping deployment-frequency enthusiasm with failure rate. It references concrete CLI usage via python3 -m minister.dora_metrics with JSON output, and recommends friction responses such as hookify rules or imbue gates rather than turning off AI help. Use it when you are growing a product with heavy agent throughput and need honest signals on whether review and restore practices kept pace with speed.1installs65DorodangoDorodango (pass-definitions) documents each quality pass in the attune dorodango polishing workflow for solo builders who want agents to improve code in layers instead of one messy refactor. Pass 1 targets correctness with the test suite and edge cases; Pass 2 targets readability without behavior changes; Pass 3 targets project conventions and patterns, optionally using style-gene-transfer when exemplars exist. Each pass states goals, scope, agent prompt focus, tools, and a clear convergence metric. Install it when you orchestrate multi-agent or multi-step polish after features land—especially if you already use the parent dorodango skill and need precise pass boundaries so agents do not scope-creep across correctness and style in one shot.1installs66Error PatternsAgent Damage Control (error-patterns) is a Claude Night Market skill that gives solo builders and small teams a shared vocabulary for multi-agent failures. Instead of treating every stall as a generic retry, it classifies issues like agent crashes, context overflow, merge conflicts after parallel edits, and mixed partial failures—each with a first-action table. A three-tier escalation ladder keeps recovery cheap at the agent level, escalates to a lead coordinator after repeated failure, and brings a human in only when severity or deadlock demands it. The patterns extend familiar transient versus permanent error thinking into agent coordination, which matters when you run several specialized agents on one repo. Use it whenever parallel agent work risks file conflicts or silent truncation, not only after incidents in production monitoring.1installs67Escalation GovernanceEscalation Governance is a journey-wide agent skill from Claude Night Market that governs when to trade speed and cost for deeper model reasoning. Solo builders orchestrating Claude Code or multi-agent stacks invoke it whenever a subtask feels stuck—not as a reflex to “try Opus,” but after systematic investigation. The skill codifies an Iron Law against casual escalation, a four-question decision framework, protocols for documenting why a tier change happened, and integration hooks for orchestrators. It applies during Build while designing routers, during Ship review when failures look like reasoning gaps, and during Operate when production incidents tempt expensive model retries. Estimated footprint is modest (~800 tokens in metadata) but the behavioral impact is large: fewer runaway token bills and clearer agent schemas.1installs68Evaluation Frameworkevaluation-framework is a meta agent skill that centralizes how Night Market plugins score and gate quality. Solo and indie builders who maintain multiple Claude skills or knowledge-intake pipelines install it so novelty, structure compliance, and domain rubrics all follow the same weighted methodology instead of copy-pasting criteria into every SKILL.md module. The integration guide shows how memory-palace and abstract-style evaluators declare dependencies and inherit scoring patterns while keeping domain-specific sections local. Use it whenever you are authoring or refactoring evaluation rubrics, aligning pass/fail thresholds, or documenting how one skill’s output should be judged before the next skill in a stack runs. It does not run evaluations by itself; it defines the framework other skills reference, which makes catalog pages and agent instructions easier to keep consistent as your plugin set grows.1installs69Extractextract is a Claude Night Market gauntlet skill that builds or rebuilds `.gauntlet/knowledge.json` from a target codebase. The agent identifies the working or user-specified directory, invokes the bundled AST extractor script, then enriches each record with natural-language business logic and architectural context. Cross-linking ties related symbols across modules; existing annotation files are preserved on merge. Solo builders and small teams use it when standing up coding challenges, onboarding agents to unfamiliar repos, or refreshing knowledge after large refactors. Category priority weights business_logic highest through error_handling lowest, shaping challenge difficulty. It is procedural infrastructure—not a one-shot lint—meant for repeatable knowledge-base generation inside the gauntlet workflow.1installs70Feature ReviewFeature Review is an agent skill that encodes a lightweight classification system for product features along a proactive versus reactive axis, with concrete implications for latency, resource use, architecture, and perceived UX. Solo and indie builders install it when they are turning ideas into shippable scope and need a shared vocabulary so agents and humans do not mix background jobs with sub-100ms interactions in the same design. The skill explains when anticipation is worth speculative cost, which patterns fit event-driven workers versus request-response APIs, and how mislabeling a feature creates wrong SLAs and angry users. It is especially useful during validate prototyping and build PM, but the same lens applies at ship when reviewing performance budgets and at grow when evaluating suggestion or lifecycle features. It is editorial methodology, not a code generator: output is clearer feature specs and review notes you can hand to implementation skills or your own backlog.1installs71File AnalysisFile-analysis is a workspace-ops skill from Claude Night Market that gives solo builders a disciplined first pass over an unfamiliar codebase. Instead of ad-hoc grepping, it walks through identifying the analysis root and monorepo boundaries, inferring language and framework from manifests like package.json or Cargo.toml, mapping directory structure at controlled depth, detecting organizational patterns, and noting hotspots worth deeper review. The skill integrates TodoWrite checkpoints so you can see progress across root identification, structure mapping, pattern detection, and hotspot notes—making it ideal input before architecture reviews, refactor roadmaps, or migration scope estimates. It deliberately defers broad exploration to a dedicated Explore agent and exact pattern hunts to Grep, which keeps the skill focused on structural cartography. Complexity is medium (intermediate): you need a repo on disk and comfort with shell tree/find commands. Dependencies referenced in metadata include sanctum:shared and imbue:proof-of-work for ecosystems that use those packages.1installs72Friction DetectorFriction-detector is an agent skill for solo and indie builders who run Claude Code (or similar) daily and want mistakes to stop repeating across sessions. It defines a friction-to-learning pipeline: detect weighted signals during execution—such as when you override the same tool call twice, deny unexpected permissions, or loop on the same action—and track them so recurring patterns can graduate into permanent project guidance instead of living only in scattered chat or LEARNINGS.md. Invoke it for session retrospectives, when you notice recurring agent mistakes, or when you want a disciplined alternative to manually running aggregate-logs after every sprint. The skill is methodology-first: it does not replace your app code review; it improves how the coding agent behaves on your repo over time. Pair it with your existing memory files and night-market gauntlet workflows when tribal knowledge and automated friction reports should feed the same long-term playbook.1installs73Gauntlet CurateGauntlet Curate is a maintainer skill for the Claude Night Market Gauntlet plugin. It surveys YAML problem banks under plugins/gauntlet/data/problems/, compares counts to neetcode_count expectations in _manifest.yaml, and surfaces the largest coverage shortfalls first via curate_problems.py. You review what already exists in thin categories before proposing new YAML entries—human review is explicit. It is meant for update-plugins runs but is not fully wired into that command yet; do not confuse it with gauntlet:curate, which handles annotation knowledge capture. Solo builders who ship agent-training or interview-prep tooling use it to keep DSA topic coverage honest without hand-counting dozens of files.1installs74Gemini DelegationGemini Delegation is an agent skill that connects Claude Night Market’s delegation-core to Google’s Gemini CLI so solo builders can offload subtasks to Gemini without rewriting their orchestration. It is for indie developers who already use multi-model setups and need a single, documented path when the router chooses Gemini or when a job exceeds what fits comfortably in a smaller window. The skill spells out model tiers, how to pipe files and directories into prompts with @path patterns, sandbox mode, and JSON output for scripted handoffs. It also covers practical ops: free-tier rate limits, trimming context with selective globs or comment stripping, and checking status via bundled hooks. Use it during Build when you are composing agent tooling stacks—not as a standalone product feature for end users.1installs75Gif GenerationGIF Generation is a procedural media skill for solo builders who capture product demos as webm or mp4 and need compact animated GIFs for distribution. It walks through validating the source file, confirming ffmpeg is installed, running conversion with explicit quality tiers, and verifying the output meets size and clarity goals. The recommended path uses ffmpeg palette generation for a balance of quality and weight; alternate paths cover fast defaults and maximum-quality dithering. Optimization options and named presets help you hit social or documentation constraints without becoming a video engineer. Use it after you have a recording—often from a night-market or agent demo pipeline—and before you embed assets in a landing page, README, or launch thread. The skill expects local shell access and disciplined TodoWrite-style checkpoints so conversions do not run on missing binaries or wrong inputs.1installs76Github Initiative PulseGitHub Initiative Pulse is a template-oriented agent skill for solo builders and tiny teams who already use a ProjectTracker-style JSON report and want consistent, scannable GitHub posts instead of ad-hoc status comments. It packages ready-made markdown for initiative scorecards, high-risk issue radars, PR watchlists, and a discussion footer that cites refresh timestamps—aligned with tracker.py status output and optional GitHub Projects filters. The digest blueprint walks you from raw tracker data through initiatives under 80% completion, pairing two wins (merged PR links), two risks (open issues), and ETA lines derived from due dates, then tabulates metrics for week-over-week comparability. It does not run the tracker itself; it teaches how to structure narrative so blockers, owners, and next milestones stay visible between syncs. Best when you ship in public on GitHub and need Minister-style pulse posts without rebuilding the format each week.1installs77Git PlatformGit Platform is an agent skill that gives solo builders a single mental model for forge operations across GitHub (`gh`), GitLab (`glab`), and Bitbucket’s REST API. Instead of guessing flag names or re-learning three toolchains, you get tabular mappings for issues and pull/merge requests—view, list, create, close, and comment—with Bitbucket spelled out as explicit HTTP calls where CLIs are thin. Use it while you are building and shipping: opening MRs from agent workflows, syncing issue state, or scripting triage in CI. It is reference-shaped integration knowledge, not a hosted bot; you still supply tokens, remotes, and repo slugs. The skill reduces agent mistakes when your org moves repos between hosts or when you maintain OSS that accepts contributions on more than one platform.1installs78Git Workspace ReviewGit Workspace Review (packaged in SKILL.md as git command patterns for Sanctum workflows) is a compact reference skill that standardizes how coding agents inspect a repository before destructive or publish steps. It lists verify-working-directory checks, short branch status, staged and unstaged diff statistics and bodies, and compare-to-main commands so reviews are consistent across stack-push, pr-prep, and commit rituals. Solo builders benefit because agents stop guessing git flags and instead follow the same diff vocabulary every session. The skill is not a standalone product feature; it is procedural knowledge meant to be composed into larger workflow skills. Use it whenever you need the agent to articulate what changed on the current branch versus main, what is staged for the next commit, and whether upstream tracking looks sane—especially on Claude Code or Cursor driving git from natural language.1installs79Graduated Implementationgraduated-implementation encodes how an agent may increase scope from one increment to the next without collapsing into “see one, do one, teach one” overconfidence. The load-bearing piece is the advancement gate: on low-stakes work (GREEN/YELLOW) the ramp token mints when the prior increment has green tests and a tradeoff entry; on high-stakes paths (RED/CRITICAL) the human must explain the actual diff on an unrehearsed question before ambition widens. Stakes flow from risk-classification—environment variable, a one-line stakes file, or a conservative path heuristic when unset. Solo builders install it when agent-assisted coding otherwise jumps from a tiny patch to a sweeping refactor with no verified understanding. The skill is methodology, not a generator: it pairs with hooks that read stakes and blocks rungs that cost less than real comprehension. Use it whenever you are about to let the agent take a larger bite after a “successful” slice, especially on security-sensitive or production-touching trees.1installs80Graph BuildGraph-build is an agent skill for solo and indie builders who want structural awareness of a codebase without hand-exploring every file. It detects the working directory (or a path you specify), chooses a full build when `.gauntlet/graph.db` is missing or an incremental update when the database already exists, and runs the bundled Python script with `--incremental` when appropriate. The output is a SQLite knowledge graph derived from tree-sitter ASTs, capturing nodes such as files, classes, functions, types, and tests plus relationship edges across calls, imports, inheritance, containment, implementation, and test links. Use it at the start of a coding session, after large refactors, or whenever you ask about codebase layout before blast-radius or flow-tracing skills. It pairs naturally with search and impact-analysis workflows in the same plugin and keeps the agent grounded in multi-language repos spanning Python, TypeScript, Go, Rust, Java, and many others.1installs81Graph SearchGraph Search is an agent skill for solo builders using Claude Night Market’s Gauntlet graph. When you know a symbol name but not its file, the skill accepts a query, invokes `graph_query.py search`, and surfaces ranked entities from the local SQLite knowledge graph. Pattern-aware ranking reduces noise compared to plain text search. Results include enough location metadata for your agent to jump straight into edits or reviews, with an explicit handoff to read the top file. The workflow assumes the graph was built beforehand; missing `.gauntlet/graph.db` triggers a clear prerequisite path to graph-build. Ideal for medium and large repos where agents otherwise burn tokens listing directories. Complexity is beginner-friendly once the graph exists; building the graph is the heavier one-time step.1installs82HardenHarden is an agent skill from the Claude Night Market catalog that walks solo builders through cross-cutting security checks that apply no matter which stack you use. Instead of language-specific lint rules, it focuses on dependency posture (committed lockfiles, audit steps in CI, Dependabot/Renovate, pinning, hash requirements, license enforcement), secret hygiene (gitleaks-style hooks, .env handling, long-lived CI secrets), and related pipeline and container/SBOM shape. Each check is labeled with IDs like DEP01 or SEC02 and tied to CWE or NIST-style guidance so you can turn findings into a prioritized fix list before release. It explicitly composes with supply-chain advisory blocklists where versions are security-critical. Indie teams shipping SaaS, APIs, or CLIs use it when they want a structured audit pass without adopting a full commercial scanner suite first.1installs83Hook AuthoringHook Authoring from athola/claude-night-market is an agent-building skill that maps Claude Code’s hook surface so solo developers can inject context, gate tool use, and coordinate subagents at precise lifecycle moments. The overview spans Setup through SessionEnd and Stop, tool hooks before and after execution (including failure paths), PermissionRequest automation, UserPromptSubmit routing, and newer notification and worktree events documented through Claude Code 2.1.69 fixes. Builders use it when shipping a plugin or internal workflow that must auto-approve safe patterns, log metrics on PostToolUse, chain tasks on TaskCompleted, or stop idle teammates with structured continue flags. It assumes familiarity with Claude Code’s hook JSON contracts and version-gated features rather than teaching general JavaScript. Outputs are hook definitions and authoring decisions tied to event types—not end-user product features. Treat it as reference-driven implementation guidance while you iterate in a real repo with plugin settings.1installs84Hook Scope GuideHook Scope Decision Guide is an agent skill for solo builders and small teams shipping Claude Code plugins or standardizing hook behavior. When you author a hook, the wrong scope causes duplicate load errors, hooks that never fire for teammates, or personal rules leaking into shared repos. The skill documents auto-loading of hooks/hooks.json when a plugin is enabled and explains why you should not mirror that path in plugin.json unless you need extra hook files. A three-column comparison covers plugin, project, and global locations with audience, git commit norms, and persistence. A short decision tree routes you by who must run the hook—plugin subscribers, everyone on the repo, or only you everywhere. Install it while designing Night Market–style plugins or enforcing codebase-specific guardrails before you paste hook JSON into the wrong settings file.1installs85Hooks Evalhooks-eval is a checker skill from the Claude Night Market skills-eval line that gives solo builders a repeatable way to grade Claude Code hooks before they go live. Instead of eyeballing a PreToolUse or PostToolUse script in chat, you run it through a 100-point Multi-Criteria Decision Analysis rubric where security carries the largest share—30 points of deductions for critical injection and eval issues down to low-severity leakage patterns. Performance is scored as its own 25-point pillar so slow or chatty hooks do not slip through on aesthetics alone. The readme ties scoring to normalized metrics and penalty-based aggregation so results stay comparable across repos. Use it when you are iterating agent-tooling under build, during ship-phase review or security hardening, or when you re-check hooks after config changes in operate. It is procedural knowledge packaged as evaluation criteria, not a hosted scanner—your agent applies the tables and gates locally against the hook source you provide.1installs86IdeateIdeate is an agent skill for solo builders who keep getting ten variations of the same idea from chat. It treats diversity as a selection problem: rotate across seven categories of ideation method (transformation, decomposition, cross-domain, and more) so each pass uses a different mental frame. The design follows “The Price of Format” (arXiv 2505.18949)—rigid output templates during generation hurt diversity; lightweight reasoning prompts raise it. You generate with flexible reasoning, then structure only the final reported set. Use it whenever repetitive LLM output blocks a design, architecture choice, or feature tradeoff, not as a one-time brainstorm ritual at project kickoff only.1installs87Install Watchdoginstall-watchdog is an egregore setup skill for solo builders who want autonomous session relaunching on a dedicated Mac or Linux host. After you initialize an egregore project, the skill walks through OS detection and runs the correct installer script so a native scheduler fires a watchdog every five minutes. That script avoids duplicate sessions, respects budget cooldown, and only starts work when the manifest still has active items—bridging long-running agent operations without babysitting terminals. It fits indie operators running personal automation or research agents outside ephemeral CI. The skill is intentionally narrow: it does not replace the egregore orchestrator on pipelines and it is wrong when you want fully manual launch control. Expect shell-level changes under LaunchAgents or systemd and verify paths match your plugin layout before enabling.1installs88JustifyJustify is a Claude Night Market workflow skill that audits completed work for additive bias and Iron Law compliance before changes land in git. Solo builders who ship with heavy AI assistance often accumulate wrappers, broad try/catch blocks, and test expectation tweaks instead of fixing root causes; this skill makes those patterns visible and demands justification per change. It runs after implementation and before commits or pull requests, including when scope-guard or self-review is needed. The audit table contrasts default helpful-model behavior with engineering behavior: fix causes, reuse helpers, prevent errors, and remove obsolete code rather than shim around it. It is intermediate complexity and acts as an entrypoint that expects imbue:proof-of-work and leyline:additive-bias-defense in the same methodology family. Use it across Build wrap-up and Ship review when you want proof-oriented merge discipline without another generic lint pass.1installs89Karpathy PrinciplesKarpathy Principles (packaged as anti-pattern drift rails) is a journey-wide agent skill for solo builders who delegate implementation to LLMs and need discipline before code lands. It encodes eight named ways agentic coding goes wrong—starting with hidden assumptions and multiple interpretations chosen silently—each with triggers, contrasting bad and good shapes, and a quick test you can run on your own diff. The skill maps rails to think-before-coding style principles adapted from community distillations of Andrej Karpathy’s notes, with attribution separated from the teaching prose. Use it whenever a feature request has unstated dimensions (scope, format, volume, privacy) or when you notice an agent shipping a default path without asking. It is meta-process, not a code generator: the deliverable is fewer silent assumptions and explicit user confirmation before implementation proceeds.1installs90Knowledge IntakeKnowledge-intake (Discussion Promotion) is a procedural module for agents acting as knowledge librarians. When a corpus entry in your digital garden reaches evergreen maturity, the skill walks through eligibility checks on the YAML `maturity` field, asks for a light confirmation (publishing is the default), resolves the GitHub repository and Discussion category IDs via `gh api graphql`, and creates or updates a Discussion in the Knowledge category. Solo builders and small teams use it to turn private or repo-local notes into durable, searchable threads that outlive a single Claude or Cursor session. The maturity table makes promotion deliberate: seedlings and growing notes stay internal until they are stable enough to share. If the Knowledge category is missing, the flow warns and skips rather than failing silently. It assumes you already maintain structured corpus entries and use GitHub as the system of record for collaborative discovery.1installs91Knowledge Locatorknowledge-locator (documented as index-structure in the bundled readme) specifies the data structures behind spatial indexing of memory palace content for agent systems that organize knowledge by place, concept, and time. Solo builders experimenting with memory-palace or Night Market–style agents get a concrete JSON schema for spatial_index, semantic_index, and temporal_index, including keywords, associations, access frequency, decay rates, and relationship graphs. The skill fits the build phase when you are implementing retrieval—not when you are validating a business idea or launching SEO. It assumes you are designing storage and query paths (hierarchical lookup, similarity via concept clusters, staleness via temporal decay) rather than writing end-user docs. Intermediate-to-advanced agent authors use it as a reference contract between locator components and downstream skills that depend on knowledge-locator in the same repo family.1installs92Latent Space Engineeringlatent-space-engineering in this catalog entry documents competitive review framing—a small methodology slice for orchestrating multiple agent reviewers on the same artifact. Solo builders running Claude Code or Cursor with parallel subagents often get shallow or duplicated feedback; this skill gives copy-paste dispatch language that nudges rigor when you have three or more reviewers by making comparison explicit, while recommending collaborative framing for only two agents to avoid overhead. It also encodes anti-gaming rules: thoroughness means evidenced, severity-prioritized findings, not inflated issue counts. Use it when you wire up code-reviewer agents, PR review toolkits, or panel-style reviews during ship gates or post-incident code sweeps. It does not replace a single-reviewer checklist; it optimizes the social mechanics of multi-agent review under competitive incentives.1installs93Makefile Generationmakefile-generation is an agent skill that writes or updates Makefiles for solo and indie builders who want one command surface for testing, linting, formatting, and routine automation. It fits early in a repo lifecycle when there is no Makefile yet, when an old Makefile is missing modern targets, or when you are standardizing the same `make` verbs across several stacks. The skill follows a fixed pipeline: detect the primary language, load the Python/Rust/TypeScript template, gather project-specific names and tools, render the file, then verify targets run. It is aimed at Claude Code–style agents with read, write, and shell access, not at replacing npm-only or exclusively Bazel-style pipelines where Make is never the source of truth. Use it to reduce tribal knowledge about how to run checks before ship and to give coding agents predictable, documented entry points instead of ad-hoc shell one-liners.1installs94Makefile ReviewMakefile-review is a best-practices module from the Claude Night Market stack that teaches agents how to structure, document, and extend GNU Make build files without common footguns. Solo and indie builders rely on Make when they want one command surface for build, test, and clean across polyglot monorepos or small services. The skill surfaces a canonical file order—project variables first, help as the default goal, explicit .PHONY declarations, and targets annotated with ## so help stays self-updating. It also catalogs pattern rules for format conversion, compiled artifacts, templated JSON configs, and parameterized pytest entry points, plus define blocks for repeating test workflows. Agents use it during review passes when a Makefile grows organically or when onboarding contributors who need predictable targets instead of tribal knowledge. It is guidance and examples, not a linter replacement, so human judgment still applies for platform-specific edge cases.1installs95Markdown FormattingMarkdown Formatting is a cross-cutting agent skill from the Claude Night Market wrapping-rules module that teaches hybrid line wrapping for prose in markdown files. Solo and indie builders (and small teams) use it whenever an AI agent drafts README sections, implementation notes, ADRs, or skill documentation that would otherwise land as single 120+ character lines and noisy diffs. The skill encodes a three-priority algorithm: prefer sentence boundaries, then clause boundaries near column 80, then breaks before conjunctions. It does not replace markdown structure (headings, lists, code fences); it targets flowing prose paragraphs inside those documents. Because the trigger is “when writing prose markdown,” it applies across validate specs, build-time docs, ship-phase changelogs, and operate runbooks—not only one journey phase. Confidence is high for documentation-heavy repos; it is lightweight (~600 estimated tokens) with no external dependencies.1installs96Math Reviewmath-review is an agent skill for solo builders who ship code where the math must be right—not merely plausible. It walks you through derivation verification: re-derive critical formulas symbolically, compare implementations to notebook checks (for example SymPy gradients), and validate probabilistic steps before they drive product logic. It then challenges approximations you often skip in a hurry: series truncation order and error, linearization validity, surrogate models against ground truth, and documented bounds tested at edges of the domain. The tone fits indie ML, simulation, pricing, and scientific backends where a wrong gradient or Bayes step is expensive. Use it during prototype review, while documenting model assumptions, or as a structured pre-ship review when formulas and numerics underpin your feature. It does not replace a full formal V&V program, but it gives your coding agent a repeatable checklist aligned with recognized modeling standards.1installs97Mcp Code ExecutionMcp-code-execution documents coordination patterns for running MCP-focused subagents either in sequence or in parallel while watching model context window (MECW) usage. Solo builders assembling non-trivial agent pipelines can apply pipeline coordination when each step depends on the last, passing trimmed next_input payloads and persisting intermediate artifacts outside the chat so failures stay isolated and tokens do not balloon. The patterns include preemptive compaction when context crosses roughly eighty percent of the limit and hard caps per subagent so focused tasks do not inherit an entire repository transcript. Guidance calls out that parallel execution became materially more reliable in Claude Code 2.1.14+, which matters when you might otherwise run three or more concurrent agents. Treat this as procedural knowledge for structuring agentic workflows—not a hosted MCP server binary—when your product logic spans multiple tool-heavy passes.1installs98Media Compositionmedia-composition is an agent skill for solo builders who already have separate GIF or video segments and need one polished tutorial file. It reads a manifest, checks that each referenced asset exists and matches expectations, then runs FFmpeg to stack, grid, concatenate, or overlay clips with documented commands for vertical tutorials, side-by-side comparisons, and PiP demos. The flow is deliberately procedural—TodoWrite checkpoints and verification after encode—so agents do not skip validation or leave broken composites. It targets content-heavy workflows: terminal plus browser walkthroughs, comparison reels, and stitched screencasts without hand-editing filter graphs every time. Install it when you are assembling multi-part media from generated or captured pieces rather than authoring a single clip from scratch, and pair it with gif-generation when clips must be created first.1installs99Memory Clarity ProbeMemory Clarity Probe is a lightweight quality-assessment skill that asks two anchor questions against any memory, summary, or live session state: what is the current task progress, and what information is still missing. Grounded in the dual-probe pattern described in recent memory-optimization research, it gives solo builders running long Claude Code or similar sessions a disciplined checkpoint before handoff, context compression, or best-of-N summary selection. The workflow is intentionally not a full rewrite tool—it judges whether retained text still supports confident continuation and flags gaps that would mislead the next agent turn. Documented integration points tie it to session palace construction and routine session checkpoints across implementation, review, and operational triage. Estimated token budget stays small, making it cheap to run often. Use it whenever you compress chat history, delegate to another agent, or store episodic memory you expect to reload hours later.1installs100Memory Palace ArchitectDomain Analysis for Memory Palaces is a workflow skill that helps solo builders and agent users decompose an unfamiliar knowledge domain before they assign rooms, loci, or narrative paths in a memory palace. You work through identifying primary concepts and their weight, documenting hierarchies and siblings, rating complexity and prerequisites, and defining how often clusters get retrieved together. The bundled YAML template turns qualitative notes into a schema an agent can extend into palace blueprints. It is not a generic brainstorming substitute; it assumes you are organizing durable reference knowledge—framework docs, certification syllabi, product domains, or codebase mental models. Journey placement starts in Idea research because you clarify the map before validating scope or writing structured docs in Build. Pair it with the broader memory-palace-architect skill family when dependencies call for a full palace design pass. Complexity is intermediate due to relationship mapping and honest complexity scoring.1installs101Metacognitive Self Modmetacognitive-self-mod is a journey-wide agent skill family for solo builders who treat coding agents as systems that should learn from their own runs. The ingested readme centers on Execution Trace Capture: each skill invocation becomes a structured trace (trace_id, skill name, timestamps, outcome, steps with tools like Read/Write and targets) wrapped in the ADR-0011 session-capture envelope so friction signals and traces share one consumer. That gives metacognitive-self-mod concrete sequences for backward-style attribution—aligned with Microsoft Trace metaphors, trajectory-informed memory literature, and ACE-style playbook evolution through generation, reflection, and curation. Use it whenever you want continuous improvement across Idea research spikes, Build implementation, Ship debugging, or Operate incident response, as long as you accept recording overhead. It is meta infrastructure, not a feature shipper: pair with trace-capture (estimated_tokens ~200 in child frontmatter) and avoid when you forbid logging tool paths or lack storage for session artifacts. Intermediate complexity; you need a repo or agent session model willing to persist JSON traces.1installs102Methodology Curatormethodology-curator packages Code Review Masters: comparative expert frameworks your agent can cite when you run or train peer review on a solo or tiny team codebase. It summarizes Google’s code health bar and comment taxonomy, Fowler’s refactoring catalog for review-time improvement ideas, Feathers’ legacy-change strategies, Wiegers’ process optimization, and Gee’s practical reviewer habits. Invoke it when you want reviews to move fast without rubber-stamping—clear nits versus blockers, approve-when-better norms, and pointers for working safely in older modules. It is editorial methodology, not an automated linter; pair it with your diff and CI context. On Prism it helps builders who ship with agents and need repeatable review language instead of one-off chat opinions.1installs103Mission Orchestratormission-orchestrator packages adaptive-constraints: a workflow-orchestration skill that scales governance with task complexity instead of loading the same rule stack for every agent mission. Indie builders running Claude Code or similar often oscillate between too little safety on tiny edits and exhausting ceremony on refactors; this module defines Minimal, Standard, and Full profiles tied to mission types from quickfix through full architecture work. Minimal keeps core safety only; Standard adds scope-guard and proof-of-work with a single checkpoint; Full enables war-room patterns, iteration governor, and extended thinking. The rationale cites diminishing returns when soft rules balloon—compliance drops and bad context hurts more than none. Use it whenever you classify work before the agent runs, so simple tasks stay in Nen-free zones and complex missions earn full enforcement without manual rewrites every session.1installs104Modular SkillsModular Skills (modular-skills-guide) is an implementation guide for solo builders who outgrow monolithic SKILL.md files and need a predictable folder contract agents can navigate. It teaches the hub-and-spoke architecture: a slim hub carrying metadata and overview, with optional spoke files for deep workflow steps, patterns, anti-patterns, and migration notes. The documented layout also wires Python helpers for skill analysis and token budgeting, plus basic and advanced example trees you can mirror in your own marketplace repo. Reach for it when you are designing a new multi-file skill, refactoring a bloated skill into modules, or onboarding collaborators on Night Market-style conventions. It depends conceptually on the parent modular-skills hub skill listed in frontmatter dependencies. The payoff is easier updates, clearer agent loading boundaries, and less surprise context burn when only one submodule is needed for a task.1installs105OnboardOnboard walks a new developer through Claude Night Market’s codebase using five staged challenge sets rather than a flat README tour. Stage 1 covers architecture and data flow at difficulty 1–2; stage 2 deepens business logic; stage 3 stresses API contracts and interfaces; stage 4 targets patterns and dependencies at difficulty 3–4; stage 5 focuses error handling and hardening before graduation. The workflow loads saved progress, shows a summary, serves five challenges from the current stage, enables hints on first attempts, tracks mastery when a learner answers correctly twice, and only advances when they hit roughly eighty percent mastery over at least ten challenges. After stage five, contributors enter the regular gauntlet without losing prior answer history. Solo maintainers and small teams use it to turn tribal codebase knowledge into repeatable onboarding instead of ad-hoc pairing marathons.1installs106Palace DiagramPalace Diagram is an intermediate agent skill in the Claude Night Market memory-palace stack. It turns structured palace data into Mermaid and ASCII views so a solo builder running long-horizon agents can see how entities link, which synapses are strong or weak, and how content sits in tiers without spelunking raw graph files. Invoke it after memory-palace-architect creates or migrates a palace, when you need an inline ASCII overview in chat, or when you are debugging why knowledge-locator retrieval paths feel disconnected. The skill explicitly defers palace creation to memory-palace-architect and code-structure diagrams to cartograph, which keeps scope tight. Prism lists it as unwired: no /palace diagram command yet, so you may need palace_manager.py until integration ships. Estimated token budget around 400 with a standard model hint fits quick inspection loops during Build. For indie agent builders, this is documentation-of-memory, not shipping customer-facing UI—it improves how confidently you evolve agent context stores before Ship.1installs107Palace Index CuratorPalace Index Curator is a governance skill for the Memory Palace web-capture pipeline. Night Market hooks append every WebFetch and WebSearch to hooks/memory-palace-index.yaml as markdown plus index rows, but defaults leave most entries pending seedlings that never graduate. Solo and indie builders who rely on captured research during long agent sessions install this skill to drain the backlog on a schedule: run analytics for corpus health, promote entries with a dry-run gate, and optionally attach SessionStart surfacing so prior fetches reappear in context. It is not for one-off ingestion or ad hoc search—those stay on knowledge-intake and normal retrieval. Think of it as the janitorial layer between passive capture and a corpus you actually trust when scoping, building, or iterating.1installs108Paperspapers is an agent research skill in the Claude Night Market / Tome family that searches academic literature through arXiv, Semantic Scholar, Unpaywall, CORE.ac.uk, PubMed Central, and author preprint pages when you need citations, formal methods, or literature reviews—not forum opinions or GitHub implementations. It orders sources for free metadata first, uses Semantic Scholar where citation graphs matter, and routes PDFs through the leyline document-conversion protocol: try markitdown’s convert_to_markdown for structured tables and equations, then fall back to paginated Read if MCP is unavailable. Triggers include building citation chains, surveying a niche before committing to an ML-heavy validate prototype, or grounding launch and grow content in citable papers. The skill explicitly deflects community takes to discourse skills and implementations to code-search, which keeps Prism journey placement honest. Solo builders wire it into Claude Code-style stacks when agent tooling must cite primary research instead of hallucinated references.1installs109Performance ReviewThis Gauntlet integration skill extends the parent performance-review capability in Claude Night Market for builders who want deeper static analysis without breaking environments that lack Gauntlet. At load time it probes for tree-sitter parsing and graph storage modules, storing sentinels so Tier-2 and Tier-3 helpers return no extra findings when dependencies are missing—mirroring proven optional-plugin patterns elsewhere in the repo. Tier 1 remains a complete performance review path; optional tiers add structure-aware and graph-scoped signals useful before merge or when investigating regressions. Solo maintainers shipping backend or API services benefit when they already run Gauntlet in CI or locally and want one skill surface for review depth. It is integration documentation and behavior for `performance_review.py`, not a standalone review from scratch. Pair it with your normal ship checklist and treat Gauntlet as an accelerator, not a hard gate unless you enforce it in CI.1installs110Plugin ReviewPlugin Review (dependency detection section) is an agent skill for the Claude Night Market workspace that teaches how to resolve which plugins need review when only part of a multi-plugin repo changes. Solo maintainers and small teams use it to avoid full-repo review fatigue: git diff against the base branch yields affected plugins under plugins/, while plugin-dependencies.json expands the blast radius to related dependents—including the case where one core plugin lists dependents as every other plugin. The skill defines deduplication so direct changes always trump merely-related status, and documents tier behavior for root-level pyproject, Makefile, or script edits plus unrecognized new plugin directories. When nothing under plugins/ moves, the workflow reports no plugin changes and passes. It is procedural knowledge for agents running scoped review pipelines, not a standalone linter binary. Intermediate complexity assumes git fluency and access to the repo's dependency manifest.1installs111Precommit SetupPrecommit-setup’s CI integration module gives solo and indie builders copy-paste GitHub Actions and GitLab-oriented patterns that run the same thorough checks as local pre-commit. The emphasis is parity: when CI only runs a subset of hooks, green pipelines still hide defects that block teammates locally. The documented flow checks out the repo, pins Python 3.12, installs uv, syncs dependencies, and executes a single comprehensive quality script—optionally uploading coverage—so one command surface exists from laptop to runner. A layered pre-commit-config example shows fast global hooks (YAML/TOML/JSON, whitespace) plus Astral Ruff with --fix. Use it while standing up or refactoring quality.yml on a Python or polyglot repo where pre-commit is already the source of truth, before merging workflow changes that could silently weaken gates.1installs112Progressive LoadingProgressive Loading is advanced documentation for skill authors who already understand basic hub-and-spoke loading and selection strategies. It explains when to escalate beyond simple splits: oversized skills that cannot be decomposed, module DAGs instead of flat lists, long sessions that require eviction, and graceful degradation when a module file is missing or fails to parse. Pattern one walks through an AdaptiveSelector that reads telemetry hits and demotes low-use modules to lower tiers. The module assumes familiarity with loading-patterns.md, selection-strategies.md, and performance-budgeting.md in the same night-market library. Solo builders shipping multi-file Claude skills use it to keep context lean without dropping capabilities. This is meta procedural knowledge—not a user-facing product generator—aimed at intermediate-to-advanced authors optimizing agent sessions.1installs113Project BrainstormingProject-brainstorming in the Claude Night Market pack includes a deferred-capture integration module that executes at the tail of a multi-phase brainstorm ritual. After the agent writes the project brief and the user chooses a winning approach in Phase 5, the skill offers to persist promising but rejected options into a deferred backlog using a small Python helper. Solo builders benefit because pivots and side bets stay searchable instead of vanishing from chat history. The UX is intentionally lightweight: count non-selected approaches, show a single capture prompt, and continue to project specification even if the user is silent for thirty seconds. This is workflow glue—not ideation itself—so invoke it only when you are already inside the Night Market brainstorm pipeline with a completed brief and recorded rejection reasons.1installs114Project ExecutionProject Execution in the Claude Night Market family is a template skill that turns finished agent work into a Mission Report—the definitive record of what shipped, why choices were made, how success was validated, and what still needs follow-up. Solo builders running long agent sessions lose context when chats end; this skill gives a copy-paste scaffold with required metadata plus optional lessons and metrics, then expects you to store it in a mission archive or attach it to PRs and issues. It pairs philosophically with in-progress Progress Reports: do not close with a Mission Report until the mission succeeds, fails, or is terminated early. Multi-phase value shows up whenever you hand off builds, prep launch evidence, or archive operational iterations. The decisions block is the standout institutional-memory pattern for indie maintainers who are their own future teammates.1installs115Project Initproject-init is a language-detection module from the claude-night-market skill set that decides whether your repo is primarily Python, Rust, or TypeScript/React before other init automation runs. It checks canonical manifest files first, falls back to counting extensions under src/, and only then prompts with a simple 1–3 menu. Edge cases include mixed-language trees and empty greenfield folders, where it either asks you to pick a primary language or assumes Python. Solo builders using Claude Night Market to standardize new repos benefit because agents get a single LANGUAGE variable instead of guessing from package.json noise. Wire it through project_detector.py as documented so subsequent scaffolding stays consistent across the monorepo-style skill bundle.1installs116Project PlanningProject-planning is an intermediate workflow skill for solo and indie builders who already have a specification and need a concrete path to implementation. It transforms requirements into a phased plan with explicit dependencies, component interfaces, and task granularity suitable for agent-led execution or human sprints. The skill intentionally sits between specification and execution: it warns against restarting planning on a running project and routes exploratory work to brainstorming or greenfield specs to project-specification. For lightweight needs it runs in-repo; for thorough program plans it defers to spec-kit:task-planning as the canonical implementation while still aligning with structured planning patterns from superpowers:writing-plans. Best used when architecture choices, dependency order, and resource allocation must be decided before any build subphase work begins.1installs117Project SpecificationProject Specification is a workflow skill for solo builders who have direction from brainstorming but lack implementation-ready requirements. It converts a project brief into structured specifications: user stories, acceptance criteria you can test, scope boundaries, and enough technical framing to feed planning and QA. The skill is intermediate complexity and prefers Claude Sonnet-class models for balanced prose and structure. It integrates with the broader attune night-market flow—brainstorm first, specify second, plan third—and delegates heavyweight spec-kit methodology to spec-kit:spec-writing when you need canonical templates and validation. Use it when business intent exists but engineers (or your agent) would otherwise guess at edge cases. Skip it when you are still exploring the problem space or when a detailed spec already exists and you only need task breakdown.1installs118Proof Of Workproof-of-work from Claude Night Market gives solo builders a disciplined way to close agent tasks without vague “done” claims. It encodes four principles—SMART criteria, binary outcomes, user-verifiable checks, and evidence links—into a reusable markdown template with acceptance bullets, per-criterion PASS/FAIL evidence, status blocks, and step-by-step instructions the user can run independently. The README includes scenario starters such as configuration setup so you can adapt the same rigor to features, integrations, or ops changes. Use it whenever an agent hands back work you need to trust before shipping: after Build implementation, during Ship review, or when validating a Validate prototype before you invest further. It does not write tests for you; it structures what “proof” means so humans and agents share one contract. Skip it only when criteria are already frozen in a signed spec with automated CI gates covering every requirement.1installs119Pr PrepPR-prep is a pull request template framework that structures submissions with required sections: a concise summary of what changed and why, a detailed changes section with grouped explanations, explicit testing validation with commands and results, and a pre-submission quality checklist. Solo builders use it to communicate intent clearly to reviewers, reduce review friction, and ensure nothing ships without documented testing. This matters because well-structured PRs speed up review cycles, reduce merge conflicts, and create accountability for quality before code reaches production.1installs120Pr Reviewpr-review is a Code Review & Quality skill that encodes comment-quality rules for pull requests and ongoing refactors. Solo builders and small teams use it when an agent drafts review feedback or suggests inline comments so explanations focus on why a choice exists—business rules, performance, workarounds, and external constraints—rather than restating what the code already shows. It pairs with good naming and patterns: comments are required where future readers would otherwise lack domain or environmental context, and discouraged where function names and structure already document behavior. For indie products shipping through GitHub-style workflows, installing this skill steadies AI-assisted reviews so feedback stays actionable and avoids comment bloat that slows merges.1installs121Pytest ConfigThis skill packages CI/CD integration patterns for pytest, centered on GitHub Actions and everyday test commands a solo or indie developer runs locally and in the cloud. It documents how to install dev extras, run full suites with HTML or XML coverage, filter by markers such as unit versus slow, rerun failures first, scale with pytest-xdist, and stop early on regressions. The workflow templates cover checkout, setup-python, editable installs, and optional codecov publishing, plus a matrix job pattern for testing across three Python versions. It is aimed at builders shipping Python libraries or services who want repeatable gates without hiring a platform team. Use it when standing up or tightening automated testing on every push rather than relying on manual pytest runs alone.1installs122Python AsyncPython Async (Advanced Async Patterns) is an agent skill from athola/claude-night-market that teaches intermediate-to-advanced asyncio idioms solo builders need when backend work stops being synchronous: async context managers for resources like database connections, async iterators for page-by-page fetching, and producer-consumer queues for backpressure-friendly pipelines. It assumes familiarity with foundational async patterns and timeout handling from sibling skills in the same collection, and packages each pattern as concise, runnable Python so you can transplant structure into FastAPI workers, scrapers, or job runners. Install it during Build when you are wiring real I/O concurrency and want guard-railed examples instead of trial-and-error around __aenter__, AsyncIterator typing, and queue coordination. It is reference material, not a deployable service—its value is fewer subtle asyncio leaks in indie APIs and agents.1installs123Python PackagingPython-packaging’s CI/CD Integration module teaches solo builders how to automate the boring part of shipping a Python library: every push and pull request runs tests and quality checks, and a published GitHub Release triggers a build and PyPI upload using uv and Astral’s setup action. The skill is aimed at indie maintainers who already have a uv-based project layout and want reproducible workflows without hand-rolling twine and legacy setuptools scripts. You reach for it when you are ready to stop manual releases or when you need a credible test matrix before you share a package on skills.sh-style agent ecosystems or internal tooling. The YAML snippets are intentionally minimal so you can drop them into `.github/workflows` and extend with caching, signing, or trusted publishing later. It pairs naturally with packaging metadata and versioning work in the parent python-packaging skill rather than replacing project scaffolding.1installs124Python PerformancePython Performance is a compact agent skill covering benchmarking tools and optimization best practices for solo builders shipping Python services or scripts. It teaches a reusable benchmark decorator that prints elapsed seconds per call, and pytest-benchmark patterns for comparing implementations like list comprehensions under test. The best-practices section stresses profiling first and targeting real bottlenecks rather than micro-optimizing cold code. Use it when your agent is rewriting loops, adding caching, or arguing about algorithm choice and you need evidence. It pairs naturally with profiling skills elsewhere in a night-market style catalog. Intermediate familiarity with pytest helps; beginners can still copy the decorator for one-off timing.1installs125Python TestingPython testing (async-testing) is a pytest-asyncio playbook for solo builders shipping async APIs, workers, and CLI tools. It walks through marking tests with pytest.mark.asyncio, building async fixtures that yield clients or connections, exercising concurrent awaits, and mocking coroutines without flaky event-loop behavior. Sections address timeouts, exception propagation, async context managers, and async generators, plus configuration notes so CI matches local runs. The skill assumes familiarity with unit-testing and fixtures-and-mocking companion skills and targets intermediate developers who already ship Python but struggle with loop-scoped fixtures or race-prone concurrent tests. Use it while implementing FastAPI handlers, asyncio pipelines, or agent backends where I/O is async end-to-end. Deliverable is copy-paste-ready test patterns verified with pytest -v, reducing ship-phase regressions without adopting a separate test framework.1installs126Quality GateQuality Gate is an orchestration skill for the egregore work-item pipeline’s QUALITY stage. Instead of ad-hoc review chat, it routes each quality step through a fixed table: code review against conventions C1–C5 via pensive:unified-review, unbloat via conserve:unbloat, refinement via pensive:code-refinement, test updates via sanctum:update-tests, and documentation plus slop detection via sanctum:update-docs and scribe:slop-detector. The orchestrator passes step, mode (self-review or pr-review), work_item_id, branch, and optionally PR number. Solo builders using egregore-style multi-agent workflows get a repeatable pre-PR ritual that mirrors team CI discipline. It does not replace raw linters; the skill itself says to use make lint for one-off format checks outside the pipeline.1installs127Quota ManagementQuota Management (packaged in Prism under athola/claude-night-market as estimation-patterns content) gives solo builders procedural patterns to forecast LLM consumption before work starts instead of discovering overages after a long agent session. It documents TOKEN_RATIOS by file type so you can approximate input size from repository paths, and a task matrix that brackets typical input and output tokens for analyses, summarization, pattern extraction, and template generation. A small cost estimator multiplies token counts by published per-million-dollar rates for common models. The skill is methodology-first: you invoke it whenever an agent is about to read many files, regenerate boilerplate, or chain multi-step tasks. It pairs naturally with night-market style agent marketplaces where quota guardrails matter. Because estimation applies before validation spikes, heavy builds, ship-time reviews, and operate iteration, treat it as journey-wide guardrails rather than a single-phase integration.1installs128Qwen Delegationqwen-delegation teaches solo builders how to route work from delegation-core to Alibaba’s Qwen family using the Qwen CLI. It is a narrow integration skill: pick the right model tier, pass prompts and files with @path patterns, and recover from rate limits or install issues without blocking your primary agent. Use it when delegation-core selects Qwen or when you need large-context batch processing that your main model would truncate or overprice. The skill catalogs practical flags, cost positioning relative to comparable providers, and verification commands so you can confirm the binary and model list on your machine. It assumes you already use a delegation orchestrator rather than calling Qwen for every chat turn, which keeps the pattern suitable for indie pipelines that mix Claude Code or Cursor with cheaper or bigger context backends.1installs129Release Health GatesRelease Health Gates is an agent skill that packages two coordinated checklists—Deployment Readiness and Quality Signals—for indie builders shipping through GitHub-backed release trains. It tells your agent to mirror readiness criteria in the deployment PR, export tracker CSV to confirm no open High-priority in-scope work, attach an executive status-report excerpt, and capture sign-offs as PR approvals with explicit handles. The quality gate insists on sustained green checks, rerun integration tests after the last commit, flaky-test tracking issues, performance benchmarks on the PR, and SRE error-budget review. Included GitHub API references help you snapshot check suites and deployment status instead of hand-waving QA. After deploy, it prompts tracker closure, a retro tied to the Release Gate comment, and artifact archival. Use when you are one person playing PM, release manager, and on-call and need a repeatable comment template auditors and future-you can trust.1installs130ResearchThe research skill is a session orchestrator for solo builders who need more than a single web search when evaluating a technical bet. It wires together GitHub code search, forum discourse, paper indexes, TRIZ depth, and synthesis into one repeatable ritual instead of ad-hoc prompt chaining. You start by classifying the topic domain; if confidence is weak, the skill pauses for human confirmation so you do not waste parallel agent runs on the wrong framing. A research planner then assigns channel weights and TRIZ depth, and SessionManager records the session metadata on disk for traceability. Dispatch uses parallel Agent-tool workers per channel, which is how indie operators compress calendar time on competitive scans, literature reviews, and “what are people actually building?” surveys. The closing synthesize step is meant to produce a formatted report you can drop into validation notes, RFCs, or pitch docs. It sits earlier in the journey than implementation skills: use it when the question is still “what is true in the market and literature?” rather than “ship this PR.” Progressive loading and an estimated token hint keep the skill usable in cost-conscious agent setups.1installs131Response CompressionResponse Compression is a journey-wide agent skill from Claude Night Market that instructs agents to remove verbose framing, filler, hedging, and hype so answers stay direct and cheaper in tokens. It documents elimination rules, before/after examples, termination and directness guidelines, and a quick reference checklist, with stated impact of 200–400 tokens saved per response. Frontmatter sets `alwaysApply: true`, so it is meant to run whenever replies feel bloated or context is filling fast—not only during coding. Skip it when you are teaching novices step-by-step or when educational depth is the goal (the skill lists those as explicit anti-patterns). Ideal for solo builders running long Claude Code or Cursor sessions on tight context budgets. It is procedural communication policy packaged as SKILL.md, not a linter or formatter on your repository.1installs132Review Chamberreview-chamber is a workflow module in the Claude Night Market stack that saves what your agent learned during pull request review into a structured review room. Solo builders shipping with agents often rerun the same review lessons because nothing persists after a thread ends; this skill scores each finding for novelty against existing entries and applicability to the project, then only keeps material worth reusing. It can fire automatically when sanctum:pr-review finishes, on demand via review-room capture, or retroactively from old PR threads. BLOCKING and IN-SCOPE findings drive capture; low-score or duplicate knowledge is skipped so the chamber stays useful. The result is classified ReviewEntry artifacts wired into the project palace with updated connections—institutional memory for code quality without another generic note app.1installs133Review CoreReview-core is procedural scaffolding for agent-led deep reviews—architecture, APIs, math, or code—so every run follows the same path from context through evidence to a structured report. Solo builders install it when ad-hoc review threads produce inconsistent severity, missing citations, or incomparable outputs across PRs. The skill does not substitute domain checklists; it enforces preflight todos, scope inventory, evidence logging, deliverable structure, grounding verification, and documented contingencies. Use at the start of a detailed review workflow in the night-market stack or standalone whenever you want findings another human or agent can diff against prior runs. Intermediate complexity because it assumes you already know what you are reviewing and can maintain TodoWrite discipline through six steps.1installs134Rigorous ReasoningRigorous Reasoning is a conflict-analysis protocol packaged as an agent skill for solo builders and small teams who use Claude or similar agents on sensitive or ambiguous situations—not just code. It walks through acknowledging bias (especially on technology, AI, grief, or culturally charged topics), then applies a harm-and-rights checklist: concrete measurable harm, independent moral verdicts, explicit rights, and careful evidentiary language. It does not replace legal advice or therapy; it keeps agent outputs from treating gut reactions as evidence. Use it whenever a disagreement, ethical question, or interpersonal scenario needs a calm, auditable reasoning pass before you commit to a product, policy, or reply.1installs135Risk ClassificationRisk Classification is a Claude Night Market skill that extends risk labeling with graduated agent autonomy. Solo and indie builders running Claude Code, Cursor, or Codex use it when a task might be low-touch docs or high-stakes production logic, and the agent must not treat every job as full auto-commit. The skill defines four automation tiers—from autonomous write-and-commit through manual human-only load-bearing code—and ties each tier to default postures for GREEN, YELLOW, and RED work. It encodes a deliberate downgrade path when automation misbehaves, mirroring aviation crew practice of reducing automation level instead of escalating the same flawed command. Use it before agents commit, refactor auth, or touch infra so verification depth and autonomy stay aligned. It complements security review and planning skills by making “propose and pause” a first-class, pre-licensed move rather than a negotiation mid-run.1installs136Rule Catalogrule-catalog from Claude Night Market captures how to define and maintain prompt-event rules—like require-slop-scan-for-docs—that warn whenever you ask an agent to write or overhaul tutorials, READMEs, guides, or changelogs. The catalog pattern documents enabled rules with regex conditions on user_prompt, warn actions, and explicit follow-up skills so documentation work cannot finish without slop review. It enumerates concrete AI tells: em dash density, buzzwords, participial tail-loading, uniform sentence length, hedging, plus 2026 consensus patterns (plus-sign conjunctions, inanimate spatial copulas, negative parallelism, throat-clearing, fragment bursts). Solo builders publishing developer content or product docs get a repeatable guardrail instead of manually remembering slop checks. Use it while configuring Night Market in Build, before Launch SEO pages, or in Grow content refreshes when agents draft customer-facing copy.1installs137Rules EvalRules-eval is an agent skill from athola’s claude-night-market that acts as a linter for Claude Code rule files. It encodes content-quality metrics—actionability, conciseness, non-conflicting guidance, and single-topic focus—and a 25-point deductive rubric that zeroes out empty files and penalizes bodies under ten words or over roughly five hundred tokens. It also documents valid frontmatter (paths globs, description) and common YAML failures when globs start with asterisks unquoted. Solo builders curating .claude/rules or similar drops use it while tightening Ship/review gates and again in Build/agent-tooling when authoring new rules so conditional path loading works. Output is qualitative fixes aligned to the scoring table, not a deployed CI service unless you wire it yourself. Pair with your repo’s rule set before onboarding contributors so agents load consistent, non-contradictory instructions.1installs138Safety Critical PatternsSafety-Critical Patterns is a code-quality skill that brings NASA JPL Power of 10 discipline into agent-assisted reviews for solo builders shipping money-moving, health-adjacent, or reliability-sensitive logic. It is not a blanket style guide: you match rigor to consequence—full rule sets on integrity-critical modules, selective checks on business logic and handlers, and a lighter pass only on throwaway scripts. The skill encodes verifiable habits such as acyclic control preferences, bounded loops, and assertion-friendly structure so static reasoning and human review agree. Invoke it during Ship before merge, or during Build when hardening core algorithms you already know will face audits. It pairs conceptually with structured review skills in the same night-market stack. It will not replace domain certifications or penetration tests; it tightens implementation patterns so catastrophic surprises are less likely.1installs139Scope GuardScope Guard is a journey-wide agent skill that encodes anti-overengineering rules for solo and indie builders who delegate implementation to Claude Code, Cursor, or Codex. Instead of letting models jump to three architectures, it requires problem, runtime, audience, pain point, and stated requirement to be clear first. It blocks abstractions until three real use cases exist, pushes hypothetical plugins and strategy patterns to the backlog, and applies a default cap of three major features per branch unless you explicitly trade scope or split work. The skill is lightweight procedural knowledge—no external APIs—meant to run whenever you feel scope expanding mid-chat. It pairs naturally with brainstorming and planning skills when a spec is still forming, and with code review when a branch has grown past its budget. Highlights include explicit refusal phrases for common rationalizations like “users might want this” or “modern apps have this,” so agents mirror a disciplined PM voice rather than a maximalist coder.1installs140Sem Integrationsem-integration is a small agent skill slice for Claude Night Market / Leyline that ensures the sem semantic diff CLI is available before your agent relies on it. Detection checks a session cache file, then falls back to `command -v sem`. If sem is missing, the agent offers prioritized install options: `cargo install --locked sem-cli` on any Rust toolchain, optional Homebrew on macOS when a formula exists, or a curl-based Linux binary into `~/.local/bin`. Users can decline and continue with ordinary git diffs. Solo builders who review large refactors install it to reduce diff noise—renames and moves read as semantic changes rather than delete/add line storms. It is an integration helper, not sem itself; you still need Rust or curl access for first-time setup.1installs141Service RegistryService Registry execution patterns document how solo builders and small teams orchestrate multiple AI coding CLIs from a single registry: expand command templates with prompts and file arguments, execute through subprocess with shlex splitting, enforce timeouts, and return structured ExecutionResult objects including token estimates. The skill targets agent-marketplace or multi-model workflows where you cannot hardcode one vendor command. It complements registry metadata (service configs, default models) with safe shell discipline so a runaway or malicious template does not block your pipeline. After adoption, agents can invoke the right backend per task while you retain observability on duration and output size—critical before you automate deploy reviews or batch refactors across repos.1installs142Session ManagementSession Management is an agent skill for organizing long-running Claude Code work with named sessions, checkpoints, and terminal or REPL resume. Solo and indie builders use it when an auth bug, feature branch, or multi-hour refactor should not be lost because the chat ended or the machine rebooted. The skill maps available commands in a table, then walks workflow patterns for debugging sessions and feature milestones so you can pause safely and pick up with the same session name. It stays lightweight—estimated around 400 tokens and fast-model friendly—and does not replace git branches or issue trackers; it complements them by binding agent context to a durable session handle. Install it when you routinely span days or sessions on one problem and want repeatable resume instead of re-explaining context from scratch.1installs143Session Palace BuilderSession Palace Builder supplies predefined palace blueprints that split an agent session into labeled rooms and halls so solo builders can run software workshops, research libraries, decision councils, or debug workshops without designing layouts from scratch. Each template names concrete zones—such as requirements, architecture, implementation, testing, review, and release for development work—so context stays scoped and handoffs between topics stay visible. The skill targets indie developers using Claude Code or similar agents who want repeatable session structure instead of ad-hoc prompts. Use it when starting a multi-step feature, investigation, architecture choice, or bug hunt and you already rely on the broader session-palace-builder capability. Templates accelerate palace creation and pair with workflow tags for layouts common across validate, build, and ship conversations.1installs144Session ReplaySession Replay is an agent skill that converts a finished Claude Code session JSONL file into an animated GIF that replays the conversation as typed terminal output—ideal for solo builders who need to show how a fix or feature actually happened without screen-recording friction. It orchestrates parsing session turns into a script, building a VHS tape representation, and delegating render to the scry:vhs-recording dependency so you get a portable visual artifact. Typical triggers include demoing agentic workflows, attaching evidence to pull requests, posting highlights to Slack or GitHub, or embedding replays in tutorials. It deliberately does not replace long-form post generation, API doc synthesis, or live terminal capture; those belong to scribe or direct VHS recording skills. Because output is derived from historical JSONL, it fits after the work is done—primarily Ship review and Launch distribution—even though the underlying session occurred during Build. Pair with PR prep or tutorial skills when you want the GIF inside a structured narrative.1installs145Session To PostSession-to-post is a narrative-structure agent skill from the Claude Night Market writing-quality module. It gives solo builders repeatable markdown templates for transforming a session brief into a dev blog article or a case study, with emphasis on concrete starting states, phased technical decisions, visible verification, and honest remaining work. The default blog flow discourages filler intros, pushes numbers in the “where we started” section, and reserves code snippets for techniques worth teaching. A dedicated verification section expects proof artifacts—test output, before/after measurements, GIFs from terminal or browser recordings—so readers trust the claim. The case study variant skews toward demonstrating tool capability to prospects while sharing the same rigor. Use it after a meaningful build or migration session when you want distribution without sounding like generic AI hype. Intermediate complexity reflects the need for real session artifacts, not invented metrics.1installs146SetupSetup is a focused provisioning skill for the Claude Night Market Oracle plugin: it prepares a local Python 3.11+ environment with uv, installs onnxruntime, and verifies the venv so an ML inference daemon can evaluate agent skill quality offline. Solo builders maintaining skill marketplaces or custom skill lint/eval pipelines use it once per machine or after environment drift—not during everyday feature coding. The skill runs a single documented bash invocation against oracle.provision, surfaces the message to the user, and sets expectations that the daemon attaches on the next session when successful. Failures point to uv or network issues rather than opaque stack traces. It is intentionally narrow infrastructure glue between your repo’s plugins/oracle code and runnable ONNX inference, keeping skill quality checks local instead of cloud-only.1installs147Shared PatternsShared Patterns is a journey-wide meta skill for builders who maintain Claude-style skills and hooks in a modular repo layout. It explains how to combine validation, workflow execution, and error-handling surfaces without duplicating logic or creating circular references between markdown modules. The documented standard order—validate required fields first, execute checklist or workflow steps second, and wrap writes and side effects in structured failure paths third—gives agents a repeatable integration recipe. Selection heuristics help choose among overlapping patterns when several modules seem to fit the same hook. Relative-path cross-links (for example from creation.md to validation-patterns.md) support progressive loading during authoring sessions. Solo developers shipping agent bundles use it whenever they extend SKILL.md libraries, debug composition bugs, or align new skills with an existing night-market pattern set. It does not replace domain skills; it keeps your skill factory consistent from Idea through Operate whenever you touch agent infrastructure.1installs148Shell Reviewshell-review is an exit-code and pipeline pitfall module from the Claude Night Market shell-review family. Solo and indie builders use it when bash CI wrappers, deploy scripts, or agent-generated shell glue pipe compiler output through grep, head, or tail and accidentally treat a filtered stream as success. The skill is procedural reference, not a live linter: it teaches pipefail, separate capture of stdout and exit status, and PIPESTATUS checks, with concrete bad and good examples around make typecheck. It pairs with code review and Ship-phase hardening for anyone shipping from GitHub Actions, local verify scripts, or Codex and Claude Code task runners. Install it when you want your agent to flag pipeline patterns that silently swallow non-zero exits before you trust a green checkmark.1installs149Skill AuthoringAdvanced Skill-Authoring Patterns is a meta skill for authors who already have a working skill and hit coordination, scale, or context failures—not missing prose in one file. It maps baseline test symptoms to concrete patterns: multi-skill coordination (one primary skill per task and explicit chains), hub-and-spoke loading when SKILL.md grows past hundreds of lines, trigger narrowing when activation is too broad, conditional activation per environment, and shared module extraction when three or more skills need the same logic. It assumes the TDD methodology from the parent night-market stack: every pattern starts from a failing baseline scenario. Solo builders shipping multiple Claude skills in one repo use it to stop parallel skills from shouting conflicting instructions and to keep discoverability high without monolithic SKILL.md files.1installs150Skill Graph AuditSkill-graph-audit interpretation teaches solo and indie builders—and small plugin maintainers—how to read dependency-graph metrics without misclassifying healthy skills as orphans. Hyperlinked skill catalogs and night-market-style repos generate isolates and hubs that look alarming until you map them to library skills consumed via dependencies or imports, entrypoints invoked by slash commands or external orchestrators, and hook-target skills referenced from PreToolUse or PostToolUse hooks. The skill is editorial procedure knowledge: when an isolate appears, you confirm callers, command files, or hook wiring instead of deleting nodes. When inbound counts spike, you treat the skill as load-bearing, enumerate Skill() references across plugins, and plan deprecation with notice and a migration path. Use it whenever you audit, refactor, or document agent skill integration—not as a trading or codegen tool, but as the interpretive layer on top of graph audit output.1installs151Skills EvalSkills-eval is a meta agent skill from Claude Night Market for analyzing how other skills behave under advanced tool use: dynamic discovery, programmatic multi-step calling, and context preservation. Solo builders and skill authors install it when a SKILL.md package is nearly ready but they need measurable signals—discovery latency, parallel call opportunities, context churn—instead of subjective chat review. The readme centers on shell-invoked analyzers under skills/skills-eval/scripts, including tool-performance-analyzer and discovery-optimizer with MCP benchmark comparisons. It fits ship-phase review for agent products and also supports build-phase agent-tooling hardening. Expect intermediate complexity: you need a skill path, local repo layout, and comfort running analysis scripts on your own packages.1installs152Slop DetectorSlop-detector (anti-goals module) is a Night Market safety skill for solo developers cleaning up LLM-heavy codebases without accidentally stripping the comments that justify non-obvious behavior. It complements aggressive de-slopping rules by defining Class 1保留 patterns: why-comments, rate-limiter rationales, and unsafe-block safety notes that look dense but are not marketing fluff. The workflow bias is conservative—flag for human decision rather than auto-delete when pattern matchers misfire. Use it during Ship when you are reviewing diffs, shrinking comment noise, or running agentic refactors on Rust or polyglot repos. It depends only on Read in metadata and fits checker-style agent sessions where quality modules stack. Not a substitute for security auditing or functional tests; it specifically prevents false-positive removals that would hide operational constraints.1installs153Smart SourcingSmart Sourcing is an agent skill that tells Claude Code, Cursor, Codex, and similar assistants when to attach real citations versus when to answer without expensive retrieval. Solo and indie builders use it before research-heavy tasks, security recommendations, or any reply that mixes version numbers, API behavior, pricing tiers, and performance benchmarks—claims that go stale fast. The skill encodes a explicit require-sources versus do-not-require matrix so agents do not default to citing everything or citing nothing. That balance matters on a one-person stack where every extra fetch multiplies tokens across long sessions. Install it when your agent over-cites trivia or under-sources breaking changes; keep it in play across Idea research, Build docs, Ship security notes, and Launch factual pages. It is procedural knowledge in SKILL.md form, not an MCP server or a scraper—you still wire search and fetch tools separately.1installs154Speckit Orchestratorspeckit-orchestrator is the coordination skill for Claude Night Market’s spec-kit: it tells your coding agent how to walk a feature from user-facing specification through technical plan, task breakdown, and checklist-backed quality gates. Solo and indie builders use it when ad-hoc prompts produce inconsistent folders or skip validation before code—spec-kit instead standardizes `specs/{N}-{short-name}/` with spec.md (what and why), plan.md (how), tasks.md (implementation order), plus research.md and data-model.md when needed, all anchored by `.specify` scripts, templates, and memory. The ingested readme documents artifact-structure as a reference dependency on speckit-orchestrator, which clarifies purposes and organization rather than replacing the orchestrator’s runtime steps. Complexity is beginner-oriented with structured templates, so it fits Validate and early Build PM work more than production monitoring. After scope is stable, you typically continue into Build subphases using tasks.md as the agent backlog and re-run checklist folders before ship-ready reviews.1installs155Spec WritingSpec-writing is an agent skill in the Claude Night Market lineage for solo builders who want requirements documents that agents can implement without constant clarification. It sits upstream of coding: you produce specs whose statements are complete enough that companion quality skills (such as checklist-dimensions, which lists spec-writing as a dependency) can audit the writing itself—whether hover states are specified, whether accessibility keyboard paths are defined, whether failure modes like broken logo images are covered. The ingested fragment emphasizes that checklists validate requirements, not whether code passes tests, which is the philosophical backbone spec-writing should instill before anyone opens an IDE. Use it when a feature idea is fuzzy, when ChatGPT plans lack measurable acceptance criteria, or when you need a handoff artifact for subagents. Multi-phase placement reflects reality: scope specs in Validate, refine during Build PM, and re-read during Ship review. Beginner-friendly dimension naming; intermediate discipline to keep requirements testable and non-implementation-focused throughout.1installs156Stack Createstack-create initializes a stacked diff workflow from a written plan: every dependent slice becomes its own branch stacked on the prior slice's branch, which keeps large features reviewable in merge order instead of one monolithic PR. Solo builders on Claude Night Market stacks install it after do-issue or attune:blueprint produces ordered steps and sanctum:git-workspace-review confirms a clean tree. Git 2.38 or newer is mandatory because older versions lack --update-refs behavior the flow assumes. The skill documents explicit TodoWrite checkpoints from version check through stack verification. When changes are independent, the docs point you to parallel worktrees rather than forcing a stack. That makes it a Build-phase PM and git primitive that extends naturally into Ship review as each layer lands.1installs157Stack ModeStack Mode is a shared contract skill for Claude Night Market commands that support a `--stack` flag or auto-detected stack membership. Solo builders and small teams using stacked diffs load it when they want one invocation to walk every PR in a dependent chain—from oldest base change to tip—in the same order Git expects, instead of manually re-running review or fix tooling on each link. The calling command must resolve membership first, run its normal workflow per PR without altering thread replies or issue links, then summarize on the stack root. It explicitly does not replace single-PR flows; it only wraps them. Pairs with sanctum stack lifecycle skills and leyline git-platform for platform-aware detection.1installs158Stack PushStack Push is a Sanctum workflow skill for solo builders who ship large changes as stacked diffs instead of one monolithic PR. After stack-create has carved branch topology and each slice has at least one commit beyond its base, you invoke stack-push to publish the whole stack: list prefixed branches, verify commits exist, push with GitHub CLI, and open or refresh dependent pull requests so reviewers can merge from the bottom up. The skill encodes naming conventions, branch verification loops, and explicit progress tracking so agents do not half-publish a stack or target the wrong base branch. It fits indie teams using gh on GitHub who already follow pr-prep and workspace review habits. Re-run it whenever any slice moves forward so open PRs stay aligned with the latest commits and the stack summary reflects current state.1installs159Stack RebaseStack-rebase walks a solo builder through cascading git rebase across an entire PR stack when the first slice merges, master picks up new commits, or a mid-stack branch changes. It assumes stacked-diff workflow from the same sanctum family: branches exist locally, remotes are fetched, and the working tree is clean. The skill is operational, not exploratory—it sequences fetch, trigger identification, rebase, conflict resolution, force-push, and PR metadata updates with explicit progress todos so agents do not skip safety steps. Intermediate git fluency is expected; force-push and stack topology mistakes can block a release train. Install when you already use stack-create and stack-push and need a repeatable cascade after merge events rather than manual one-branch rebases.1installs160StewardshipStewardship encodes night-market style care and curiosity for anyone who will inherit your work—whether that is a teammate, open-source contributor, or you in six months. Solo builders install it when they want the agent to pressure-test error messages, parameter names, bug-fix comments, plugin READMEs, and skill frontmatter before shipping. The skill contrasts genuine care (honest difficulty, navigable complexity) with noise such as increment-x comments or documentation written to look thorough instead of to help. It spans Build when authoring skills and Getting Started sections, Ship when re-reading changes as a stranger would, Launch when plugin READMEs must match reality, and Operate when iterative fixes should leave recognizable failure-mode notes. It is philosophy and practice prompts rather than a linter integration, so it pairs well with any stack where human readability and agent discoverability matter.1installs161Storage TemplatesStorage Templates (packaged as lifecycle-stages in SKILL.md) gives solo builders a lightweight content operations system for markdown libraries, agent memory folders, and product notes. Instead of treating every file as equally final, it defines four maturity stages—Seedling for quick captures, Growing for drafts under active validation, Evergreen for durable reference, and Archive for deprecated material—with explicit time horizons and promotion criteria. Seedlings use minimal structure and short review cycles; Growing content expects links, updates, and medium investment; Evergreen is the curated layer agents and future-you should trust. The skill pairs with storage-templates dependency so filenames and frontmatter stay consistent across a repo or personal knowledge base. It fits indie workflows where one person juggles research, specs, and ship notes without a CMS. Use it when unstructured folders slow down retrieval or when agents pull stale context because nothing ever graduates or gets archived.1installs162Structured OutputStructured Output is an agent skill that standardizes how you package review and analysis results so stakeholders can compare runs and act on the same fields every time. Solo builders use it when a security pass, architecture review, or post-mortem would otherwise land as inconsistent markdown in chat. The flow walks you through template selection, normalized finding blocks, concrete next actions, and an appendix for raw evidence—aligned with the Night Market output-patterns category. It pairs with proof-of-work style verification so claims in the report trace back to checks you actually ran. Complexity stays beginner-friendly with a fast model hint, making it practical for indie teams without a dedicated technical writing function. Invoke it at the end of any analytical pass, not at the start of research, so the narrative stays decision-oriented rather than exploratory.1installs163Style LearnerStyle Learner is an exemplar-reference module for solo builders who want agent-written docs, emails, and UI copy to sound like their own technical writing—not generic LLM tone. It instructs the agent to harvest short, representative passages from files such as architecture docs, selecting segments that show sentence rhythm, vocabulary, formality, and paragraph structure while rejecting transitions, heavy quotes, and one-off formatting. Each exemplar is documented with source location, word count, a blockquote of the text, and bullet notes on measurable traits like average sentence length or use of specific numbers. The 50–150 word window keeps patterns dense enough to learn from without diluting signal. Use it when onboarding an agent to a codebase voice before drafting new chapters, changelog entries, or in-app help; it is analysis and curation, not a full editorial rewrite. Pair with human review because exemplars encode preference, not compliance rules.1installs164Subagent TestingSubagent Testing is an agent skill from the Claude Night Market lineage that teaches how to validate SKILL.md effectiveness using fresh Claude instances instead of the conversation where the skill was written. Solo skill authors often get false positives because the model is primed, cooperative, and aware of test intent; this skill documents why that invalidates results and how baseline RED-phase testing without the skill establishes honest behavior. It fits multi-phase journey placement: you build the skill in Build → agent-tooling, then run subagent tests in Ship → testing before trusting gates or publishing to a catalog. The prose is methodology-heavy—setup for new conversations, no skill active, realistic user prompts—rather than a script that executes tests automatically. Use it when hardening procedural skills that must resist time pressure and shortcutting. It pairs naturally with eval-oriented meta skills after you have a draft SKILL.md ready to stress-test.1installs165SummonSummon exposes the Budget module from the Claude Night Market egregore stack: a token-window management protocol for solo builders who run multi-session agent workflows without blowing API limits. It defines how the orchestrator reads and updates `.egregore/budget.json`, rolls sessions inside a default five-hour window, and reacts when Claude returns throttling signals. Rate-limit detection covers 429 responses, embedded rate-limit messages, and retry-after headers; on hit, work halts and cooldown begins using a padded schedule so a watchdog does not immediately re-trigger the same cap. The skill is for indie operators wiring custom agent runtimes or Night Market–style summon flows, not for one-off chat turns. Use it when you need predictable shutdown and resume behavior across chained skill invocations. It complements generic retry logic by making budget state explicit and session-aware.1installs166Supply Chain AdvisorySupply Chain Advisory is an agent skill for responding to and preventing dependency supply-chain incidents, especially compromised Python packages on PyPI. It ships structured metadata on known bad versions alongside a triage checklist to search lockfiles and virtualenvs, identify malicious file indicators, and contain credential-exfiltration risk without destroying forensic evidence. Solo builders using agents that install packages rapidly benefit because one poisoned dependency can harvest environment variables, SSH keys, cloud tokens, and database passwords. Invoke it when news breaks about a maintainer compromise, when auditing installs after a security bulletin, or when wiring proactive checks at session start. The skill complements generic code review by focusing on package integrity, containment order, and documented severity rather than feature work.1installs167Synthesizesynthesize is a Tome-family agent skill that closes the loop on multi-channel research. After parallel research agents return raw hits, you invoke it to merge duplicates, rank signal, group by theme, and emit a polished markdown artifact—either a full sectioned report, a condensed brief, or a raw session transcript. Solo builders use it when Perplexity-style depth would otherwise stay fragmented across chat threads. The skill is intentionally narrow: it does not replace starting research (`/tome:research`) or deepening one channel (`/tome:dig`). That separation keeps agent workflows composable. Tag it as multi-phase because the same ranked report feeds Validate scoping, Build prioritization, and Launch messaging, but the canonical Prism shelf remains Idea research where synthesis first earns its keep. Intermediate complexity reflects dependency on an active research session and correct upstream payloads rather than beginner-one-shot prompts.1installs168Task PlanningTask-planning is an agent skill from Claude Night Market that teaches dependency patterns for breaking specs into TASK-xxx items with explicit sequential links and parallel [P] markers. Solo builders use it when an agent would otherwise run unrelated features in random order or collide on the same files. Sequential dependencies apply when a later task modifies another task’s output, needs its interfaces, tests its behavior, or touches overlapping paths; parallel tasks share only an early foundation task and operate on separate files such as auth versus storage services. Each task entry lists dependencies and affected files so coding agents can schedule work without race conditions. The skill fits the build phase PM shelf but also helps at validate scope when you need a honest parallelization map before committing to a timeline. Pair it with plan-writing or squad-style pipelines so the dependency graph becomes the executable contract for your agent run.1installs169Tech Tutorialtech-tutorial is an agent skill from the Claude Night Market code-examples module that teaches solo builders how to write technical tutorials readers can actually run. It elevates code blocks from decoration to verified procedures: you execute each command, capture real output, and only then embed commands and results in markdown. Formatting rules cover language identifiers, separating command fences from labeled Output sections, and marking untested paths instead of inventing terminal text. That discipline matters for CLI tools, API quickstarts, and internal runbooks indie founders publish to support onboarding and SEO. The skill is methodology for doc authors and agent writers, not a generator that scaffolds whole sites. Pair it whenever you ship README walkthroughs, integration guides, or course lessons where a single wrong npm or node line erodes trust.1installs170Testing Quality Standardstesting-quality-standards (packaged here as anti-patterns content under claude-night-market) gives solo builders a compact guardrail set for test code agents generate. Instead of abstract advice, it shows bad pytest snippets beside fixes: stop asserting on private methods, do not mock arithmetic you can run for real, always assert outcomes, and isolate tests from shared mutable fixtures. The frontmatter ties it to a parent testing-quality-standards skill and notes reuse by test-review and python-testing workflows, so it fits a larger Leyline-style quality stack. Invoke it when an agent drafts tests that look verbose but prove nothing, or when you want review comments grounded in recognizable smells. It is strongest for Python pytest services but the principles transfer to other frameworks. Complexity is beginner-friendly because examples are short; confidence is slightly lower where the ingested readme truncated mid-example. Pair with a test generator or TDD skill for green-field suites, and with code review skills when auditing an existing module before ship.1installs171Test ReviewTest-review is a specialized checker skill for maintainers of agent skills and plugin documentation who need tests that prove semantic correctness—not just that a file mentions a section heading. It extends scenario quality review with a Content Depth dimension rated from none through L3+ cross-plugin validation, using a five-level table and concrete flag rules. During test review you score whether assertions parse embedded examples, validate schema structure, enforce decision-framework contracts, and avoid brittle prose or exact-wording checks that belong in slop detectors rather than behavioral tests. The readme anchors on Leyline testing-quality standards modules and gives anti-pattern guidance with better approaches for each mistake. Solo builders packaging skills for Claude Code or night-market-style ecosystems use it before Ship to prevent regressions when SKILL.md wording shifts but behavior must remain stable. It pairs naturally with broader code or scenario review in the same repo but does not replace end-to-end application testing.1installs172Test UpdatesTest-updates in the Claude Night Market catalog is a BDD patterns module—not a one-shot test runner—that helps solo builders and small teams write tests agents and humans can read alike. It documents three complementary styles: Gherkin feature files for complex, cross-functional workflows; BDD-pytest for developer-centric unit and API coverage; and lightweight docstring BDD when speed beats ceremony. A decision table steers you toward the right style by complexity and collaboration needs, while mixing rules keep critical user journeys in Gherkin without forcing every helper into feature files. Best practices cover scenario naming, organizing related cases in classes with setup and teardown, and separating preconditions, actions, and expectations. Use it when you are expanding or refactoring tests during Ship prep or while building backend and API surfaces, so new specs stay behavior-focused and documentation-friendly rather than brittle assertion dumps.1installs173Tiered AuditTiered-audit (escalation-criteria in SKILL.md) is a scoping skill for progressive codebase audits. It tells solo builders and small teams when to move from lightweight Tier 1 git-history analysis to Tier 2 targeted area review and ultimately Tier 3 full-codebase scrutiny—only when prior-tier evidence justifies the cost. Criteria are explicit and countable: churn hotspots where multiple files in one module change repeatedly, fix-on-fix instability, oversized commits, missing tests alongside implementation, reverts, and clusters of new files that may lack review coverage. That makes the skill valuable in Ship when you are triaging what to review before merge or release, and in Operate when post-incident forensics needs a disciplined widen-the-lens rule. It does not run audits itself; it defines the escalation contract so agents or humans do not either under-review hot modules or burn tokens on whole-repo passes without cause.1installs174Token ConservationToken Conservation is a journey-wide agent skill from Claude Night Market that enforces quota awareness and disciplined context loading at the start of every session. Solo and indie builders who ship with Claude Code hit rolling and weekly token caps quickly when agents read wide trees or run long tool chains; this workflow turns conservation into explicit todos instead of reactive trimming. You record session duration and budget, set a discovery read budget before opening files, review delegation versus doing work inline, and log compression choices so spikes are visible early. It pairs with progressive loading and defers to dedicated context-optimization when that path already covers the scenario. The skill is procedural knowledge—no MCP server—meant for builders who want predictable agent sessions without sacrificing depth on the tasks that matter.1installs175Triztriz is a claude-night-market agent skill that applies Altshuller’s Theory of Inventive Problem Solving through cross-domain analogical reasoning. Solo builders install it when a feature, architecture, or growth mechanic feels boxed in and compromise trades keep making things worse. The skill walks through an Ideal Final Result, names technical contradictions (improving X worsens Y), handles physical contradictions with separation in time, space, condition, or scale, and escalates analysis depth from a single adjacent field up to five distant fields with principle suggestions. It is intentionally not a literature-review or ripgrep replacement—use other channels for known solutions. Because triggers are “stuck and need inventive perspectives,” it belongs journey-wide even though Prism shelves it first under Idea research for discovery workflows.1installs176Tutorial UpdatesTutorial Updates centers on manifest parsing for tutorial orchestration in the Claude Night Market toolchain. Solo builders maintaining product walkthroughs can define YAML manifests that list tape recordings, Playwright browser specs, and static GIFs, then apply composition rules for padding, background color, and layout. The module documents required fields, relative source paths, and options overrides such as fps and width for terminal captures. It fits Prism’s Build docs shelf but spans into Launch when refreshing distribution assets. Agents use it when tutorial repos outgrow hand-managed asset lists and need a single schema for regeneration. It assumes familiarity with VHS tape files and optional Playwright setup; it does not replace your CI secrets or hosting for npm serve steps. Extend with your own validators once manifests grow beyond the documented component trio.1installs177Unified ReviewUnified Review in the Claude Night Market pensive stack is really powered by output-format-templates: a small, reusable skill that defines how every review type should look on the page. Solo builders and tiny teams use it when they want agent-driven reviews—bugs, APIs, architecture, tests, Rust, Makefiles, math—to produce comparable executive summaries, severity counts, and prioritized action items instead of one-off chat rambling. The template encodes severity tiers (Critical through Low), location pointers, evidence snippets, and a “why this matters” narrative tied to proof references such as OWASP or language docs. It does not perform the review logic itself; parent skill pensive:shared and specialized reviewers supply domain rules while this skill enforces consistent structure for AEO-friendly, citable reports. Install it when you chain multiple pensive reviewers or unified-review and need one deliverable shape for stakeholders and follow-up tickets.1installs178Uninstall WatchdogUninstall Watchdog is an agent skill for solo builders who used the egregore install-watchdog flow and now want manual sessions or a full plugin exit. It walks through OS detection, then tears down the watchdog on macOS via LaunchAgents and on Linux via user systemd timer and service units, including unload, disable, file deletion, and reload where needed. The skill mirrors the install path so you do not leave orphaned plists or unit files that could confuse future automation. Use it when autonomous relaunching is unwanted, before removing the egregore plugin from a project, or when switching from daemon mode to hand-invoked runs. It is procedural shell work your coding agent can execute step by step rather than a hosted integration. Pair it with verify steps in the doc before uninstall if you are unsure whether the daemon was ever installed.1installs179Update ReadmeUpdate-readme is an agent skill that guides solo builders through finding, scoring, and emulating excellent GitHub READMEs before rewriting their own. It layers language-specific and framework-specific web search templates with quality heuristics—logical section order, quickstarts under five minutes, runnable code samples, and clear installation paths—so documentation matches what maintainers of popular projects already do well. Use it when launching or refreshing a library, CLI, or SaaS repo where the README is the primary conversion surface but you lack a technical writer on staff. The skill emphasizes progressive disclosure and exemplar-driven structure rather than generic markdown filler, which helps agents produce consistent, scannable docs that support both human visitors and AI-search citations. It fits indie workflows where the README is often the only marketing and support doc you will ship in v1.1installs180Usage Loggingusage-logging (documented as log-formats in SKILL.md) is a reference skill for structured agent and service usage telemetry written as JSONL. Solo builders running Claude Night Market–style automations use it when every shell or API invocation should leave a comparable audit trail: ISO timestamps, session identifiers, operation names, token counts, boolean success, durations, and optional metadata blocks tuned for file batches or model calls. The skill is not a logger implementation—it prescribes schemas and bash/jq patterns so you can grep a day, compute success ratios, or surface expensive operations without inventing a new format per project. It pairs naturally with grow-phase analytics and operate-phase incident review when failures spike. Install it when you are about to wire hooks or scripts that emit usage.jsonl and want agents to append consistent fields rather than ad-hoc printf lines.1installs181Utilityutility is a journey-wide agent orchestration skill from the Claude Night Market stack that treats each step as a utility maximization problem. Solo builders wiring multi-agent or dispatch flows can use it whenever the agent must choose among respond, retrieve, tool_call, verify, delegate, or stop instead of guessing the next move. Input expects session state from state-builder plus per-candidate component scores; the procedure enumerates scope-appropriate actions, ranks them by U(a), checks termination, and emits an action report for executors. Self scope may delegate into nested dispatch evaluations; subagents omit delegate; dispatch scopes manage fleets. It is intermediate complexity agent-tooling for Claude Code-style systems where explicit economics of steps matter. Use during Build when designing rituals, during Ship when debugging agent loops, or during Operate when tuning lambda weights for cost and redundancy.1installs182Version UpdatesVersion Updates is an agent skill from the Claude Night Market sanctum stack that standardizes semver bumps, changelog edits, and cross-file version alignment when a solo builder is preparing a release. It is aimed at maintainers of polyglot repos who otherwise miss a nested pyproject.toml or drift between package.json and Cargo.toml. The workflow insists on git-workspace-review beforehand, then walks through context, target discovery via glob search, applying the version, updating docs, and verification. It deliberately excludes pure documentation-only edits and full pull-request packaging, pointing those to sibling skills. For indie hackers shipping CLI tools, SaaS backends, or libraries on a cadence, it turns ad-hoc version edits into a repeatable checklist your coding agent can execute without leaving stale version literals behind.1installs183Vhs RecordingVHS Recording is an execution-focused agent skill for Charmbracelet VHS—the tool that turns terminal interactions into shareable GIFs and videos from declarative tape files. Solo builders and CLI authors use it when README screenshots are not enough and prospects need to see real commands, flags, and agent sessions in motion. The guide walks through verifying VHS and dependencies (ttyd, ffmpeg), validating tape syntax, configuring environment variables and working directories inside tapes, and running recordings with standard or custom outputs. That workflow supports polished developer documentation during Build and reusable demo clips during Launch when you distribute on GitHub, social posts, or product pages. Intermediate complexity reflects shell tooling, local installs, and ffmpeg-backed encoding rather than clicking through a GUI recorder. It complements agent-assisted tape authoring when another skill generates the .tape file content.1installs184Voice ExtractVoice-extract is the register-creation module in the Claude Night Market voice stack. After an extraction pass analyzes a founder’s writing samples, this skill tells the agent how to materialize durable markdown registers—starting with a default profile that captures vocabulary directives, sentence rhythm, rhetorical habits, and qualitative voice markers. Solo builders use it to stop re-pasting style guides into every chat when they ship newsletters, docs, landing updates, or support macros. The module also explains how to spin context-specific registers by re-running extraction on focused samples and documenting only deltas through Inherits, Overrides, and Additions blocks. Detection hooks describe how the companion voice-generate skill should pick a register when the user names a mode like casual or technical. Estimated footprint is modest (~400 tokens in metadata), but the outcome is filesystem-backed voice assets agents can reload across sessions.1installs185Voice Generatevoice-generate is a Claude Night Market generation-pipeline module that takes source material framed as raw notes, loads voice profile plus register and craft rules, and produces reviewed-ready text using Opus for tonal control. Immediately after generation it silently applies context-aware em dash replacement and swaps or removes common AI-ish phrases before any human sees the draft. Builders can optionally snapshot pre-review state, dispatch parallel review agents, present advisories, apply user decisions, and snapshot again when learning mode is active; final text may still be hand-edited with /voice-learn capturing deltas later. Estimated footprint is on the order of five hundred tokens for the module stub, with dependencies on Read, Write, and Agent primitives. Use it when you want repeatable branded copy without re-litigating style rules in every chat thread.1installs186Voice LearnVoice Learn is a pattern-analysis agent skill module that helps solo builders and content-heavy founders train agents on how they actually edit—not just brand adjectives. It ingests paired snapshots of text after automated review and after the writer’s manual pass, then classifies deltas across eight categories from tone softening to irreverent asides. The analysis prompt steers agents toward recurring preferences: if the same adjustment appears twice or more, it counts as a durable voice signal. Dependencies are Read and Agent tooling within the Claude Night Market stack, with a compact token budget suited for iterative content workflows. Use it when generic AI copy keeps missing your hedging, humor, or precision habits and you want procedural memory extracted from real diffs rather than one-shot style instructions.1installs187Voice ReviewVoice-review is a Scribe-family checker skill that dispatches two parallel reviewers on generated prose before a solo builder publishes. It loads the draft, the active voice register, and banned phrases, then runs a prose pass for AI slop and drift plus a craft pass for structural voice devices. Hard violations—including banned phrases and em dashes—are auto-corrected; softer issues surface as advisory tables for you to accept or edit. The workflow assumes prior voice-extract and voice-generate work and pairs naturally with slop-detector in a Night Market content stack. Use it when markdown or text under `**/*.{md,txt}` is ready for a quality gate but not yet live. It fits Ship review as the primary shelf and Launch or Grow content when polishing posts, lifecycle emails, or docs. Medium complexity: you need registers and dependencies installed, but the steps are explicit todos rather than open-ended rewriting.1installs188Vow Enforcementvow-enforcement is a methodology skill from the Night Market / imbue stack for solo builders who run Claude Code-style agents under real project rules. It treats compliance as engineering: classify constraints, decide which belong in firewall-like settings versus handbook-like CLAUDE.md guidance, and design graduation from soft to hard enforcement before rule sprawl collapses compliance past roughly 150 soft rules. The skill documents vow inventory, integration with proof-of-work, scope-guard, and justify dependencies, and Nen Court when agents need adjudication instead of silent rule breaks. It is intermediate governance work—valuable whenever you are drafting or auditing enforcement, not when you only need a quick lint fix. Journey-wide because constraint design precedes implementation, gates shipping reviews, and supports ongoing operational audits; invoke it before expanding agent policy or after incidents where agents ignored stated vows.1installs189War RoomWar-room (Deferred Capture module) is an integration skill for solo builders and small teams running multi-role agent war-room sessions who do not want losing courses of action to vanish after a vote. After Phase 5 voting and narrowing, it instructs the agent to persist rejected COAs that still earned Borda support and to mine the Dissenting Views section for explicit future-work items. Each capture feeds a deferred backlog entry with title, war-room source context, rejection rationale, artifact path in strategeion, and session id through a Python helper script. The workflow is procedural glue between deliberation docs and a durable backlog—not a replacement for the full war-room orchestration skill. Use it when closing a strategy session so minority options and “revisit later” ideas remain traceable when you iterate in Operate or the next Build cycle.1installs190War Room CheckpointWar Room Checkpoint is a journey-wide agent skill library that Athola-style commands call when a workflow hits a high-stakes fork—merge conflicts, irreversible deploys, scope cuts, or security-sensitive PR paths. It scores how reversible the pending choice is, computes confidence against profile thresholds, and either returns a quick express recommendation or escalates to the full War Room skill. Solo builders benefit because one-person teams skip formal review boards yet still need a consistent “stop and think” gate before damage is hard to undo. Wire it into `/do-issue`, `/pr-review`, or similar automation so every risky branch gets the same RS math instead of ad-hoc gut feel. After changes to checkpoint logic, run `make test-checkpoint` to keep escalation behavior trustworthy.1installs191Workflow DiagramWorkflow Diagram is an agent skill for solo builders who need trustworthy visuals of how work moves through their repo—deployment pipelines, git hook chains, Makefile targets, or application lifecycle states—without hand-drawing boxes that drift from reality. It prescribes a disciplined two-step flow: dispatch a codebase explorer scoped to process steps, conditionals, and transitions, then translate that structural model into Mermaid with shape semantics that distinguish decisions, subprocesses, and sync points. Frontmatter positions it for CI/CD and lifecycle documentation when someone asks what runs in what order. The skill is generator-shaped documentation aid, not a diagram hosting service; output is paste-ready Mermaid for wikis, PRs, or internal docs. Intermediate complexity reflects agent orchestration plus graph design rules. Use when prose runbooks fail and you want a living map anchored in actual config and entrypoints.1installs192Workflow ImprovementWorkflow Improvement is a journey-wide agent skill module that encodes how to automatically open GitHub issues when a workflow classifies follow-ups as deferred, backlog, out-of-scope, or suggestion. Solo builders running PR reviews, plugin audits, or multi-step agent rituals often spot real improvements they cannot ship in the same session; without a default capture path, those notes die in chat logs. This skill documents the collection format, when to append items during analysis, and how to invoke auto-creation after the workflow completes so tracking stays honest. It is procedural knowledge—not a hosted bot—meant to be included or referenced by other night-market style workflows. Use it whenever your agent tags enhancement or low-priority work and you want deterministic issue titles, labels, and file references instead of ad-hoc reminders.1installs193Workflow Monitorworkflow-monitor documents detection patterns for errors and inefficiencies in long-running Claude or Codex-style workflows. Solo builders who chain shell commands through an agent install it to recognize command failures via exit codes and stderr, timeout events, excessive retries of the same command, context window exhaustion, and bloated command output. The readme supplies concrete bash and Python snippets you can embed in monitors, hooks, or review scripts rather than a single packaged CLI. It is journey-wide because brittle automation shows up while building features, shipping tests, growing ops scripts, and operating daily agent sessions. The skill is procedural pattern reference—intermediate complexity assumes you can wire detection into your night-market or custom orchestration layer.1installs194Workflow SetupWorkflow-setup is an agent skill that configures GitHub Actions CI/CD for solo and indie builders shipping Python, Rust, or TypeScript code. It walks a repeatable pipeline: read what already exists under .github/workflows, decide which test, lint, and deployment jobs are missing, materialize templates aligned to the detected stack, and validate the resulting YAML. The skill encodes opinionated best practices such as current action versions, Python matrix testing, and dependency caching so small teams get dependable automation without becoming GitHub Actions specialists. Use it when you spin up a new repository, inherit a project with no CI, or need to modernize brittle workflows before you rely on agents to merge and ship. It is procedural packaging for Claude Code, Cursor, and Codex—not a hosted runner or MCP server—so you still own secrets, branch protection, and deploy targets in GitHub.1installs195Writing RulesWriting-rules is an agent skill for authoring Hookify behavioral rules in markdown that constrain what Claude Code can do in a session. Solo and indie builders use it when they need durable guardrails—not one-off prompts—to block dangerous commands, flag risky edits, or require checks before destructive operations. The guide walks through rule structure, event types, condition builders, regex patterns, and concrete examples from blocking rm-style commands to protecting production files. It fits anyone shipping with agentic coding who wants filesystem and shell safety encoded as versionable rules. Complexity is beginner-oriented with an estimated ~2500-token footprint and a fast-model hint. Invoke it when adding safety guardrails or when you must prevent specific commands from ever reaching execution.1installs