yerros
UserClaude Code plugin for disciplined AI development — spec-driven builds, real verification, and project memory that survives every session.
Categories
Indexed Skills (23)
forge-align
This skill should be used to find and fix code-consistency drift between similar features in a Context Forge project — phrases like "forge-align", "check code consistency", "these features are written differently", "the CRUD features are inconsistent", "unify the patterns", or "why does every feature look different". It maps feature families via the forge-aligner agent, reports divergences against the exemplar, registers missing patterns in patterns.md, and turns approved alignments into refactor units built with the normal discipline.
forge-audit
This skill should be used to check whether a project's context files still match the actual codebase — phrases like "forge-audit", "audit the context files", "are the docs still accurate", "check for context drift", or "sync context with the code". It compares each of the six files against real evidence in the repo and reports drift, then offers to update the docs.
forge-brainstorm
This skill should be used for grounded ideation in a Context Forge methodology project — phrases like "forge-brainstorm", "brainstorm ideas for X", "what should we build next", "I have a vague idea", "explore options for", "which approach is better", or "help me think this through". It acts as a senior IT consultant: diverges into options, benchmarks them against how the industry actually solves this, stress-tests each against the project's scope, invariants, and lessons plus real-world engineering standards (cost of ownership, security, operability, team reality), converges on an opinionated recommendation, and routes the outcome (forge-feature / forge-decision / the context/ideas.md parking lot) so good ideas never evaporate. Planning only — it never writes code.
forge-build-all
This skill should be used to build every remaining unit in a Context Forge Methodology project in one continuous run — phrases like "forge-build-all", "build all units", "run the whole build", "build everything", "loop until the build plan is done", "finish all the specs", or "autonomous build". It runs the tests-first → implement → verify → close loop for each pending unit in order, updating the tracker after each, and stops on the first failure.
forge-build
This skill should be used to implement one build unit in a project that uses the Context Forge methodology — phrases like "forge-build", "build unit NN", "run the build loop", "implement the next unit", or "build the next spec". It runs the disciplined tests-first (red) → implement (green) → verify → close loop for a single spec'd unit and keeps the progress tracker in sync.
forge-compact
This skill should be used to shrink the recurring token cost of a Context Forge Methodology project — phrases like "forge-compact", "compact the context", "the context files are too big", "reduce token usage", "trim the context files", "generate the digest", or "make resume cheaper". It measures every context file against its soft budget, compresses over-budget files with user approval (never dropping facts), rotates tracker history, and (re)generates the compact context-digest.md used for tiered loading.
forge-debug
This skill should be used when implementation is stuck or the agent keeps getting something wrong in a Context Forge project — phrases like "forge-debug", "this keeps failing", "the agent can't fix this", "we're going in circles", "stuck on a bug", or "it broke again". It runs a disciplined stop-and-diagnose strategy instead of thrashing with more guesses.
forge-decision
This skill should be used to log an architecture decision in a Context Forge Methodology project — phrases like "forge-decision", "log this decision", "record an ADR", "we decided to...", "document why we chose X", or "add a decision record". It appends a structured ADR entry to context/decisions.md.
forge-feature
This skill should be used to add a new feature to an existing project that uses the Context Forge methodology — phrases like "forge-feature", "add a feature", "I want to add X to the app", "plan a new feature", or "extend the build plan". It updates scope in project-overview.md, inserts correctly-ordered units into the build plan, and generates the spec(s) — without breaking existing work.
forge-fix
This skill should be used when a bug is reported in already-built work in a Context Forge methodology project — phrases like "forge-fix", "there's a bug in X", "fix this bug", "X is broken", "this stopped working", or "users report an error in Y". It intakes and reproduces the bug, triages it (fix directly when the cause is obvious; hand off to forge-debug when it isn't), and closes with the same discipline as a build unit — regression test pinned red before the fix, tracker updated, lesson captured, shipped via forge-pr. NOT for being stuck after repeated failed fixes (that is forge-debug) or for correcting the unit currently being built (that is forge-build's loop).
forge-health
This skill should be used for a whole-codebase quality (QA/QC) audit in a Context Forge project — phrases like "forge-health", "health check", "QA the codebase", "audit code quality", "how healthy is this project", "check test coverage", or "security and quality review". It sweeps five dimensions (test-suite health, error handling, basic security hygiene, performance smells, dead code) via the scout and reviewer agents, and routes findings into the normal fix/refactor pipeline. Distinct from forge-audit (docs vs code) and forge-align (consistency): this checks the quality of the code itself.
forge-init
This skill should be used when the user wants to set up the Context Forge Methodology in a project — phrases like "init context", "set up context files", "scaffold the six files", "forge-init", "create CLAUDE.md and context docs", "analyze this project and fill the context templates", or "bootstrap AI context for this codebase". Works for both new (greenfield) projects via a planning conversation and existing (brownfield) projects by analyzing the codebase and filling the templates from real evidence, then confirming with the user before writing. Also recognizes projects that already have the context files (manual or prior runs) and reconciles gaps without overwriting.
forge-lesson
This skill should be used to save or manage persistent memory in a Context Forge Methodology project — phrases like "forge-lesson", "remember this", "log a lesson", "don't make that mistake again", "note this for next time", "save this as a preference", or "forget that lesson". It appends a distilled one-line lesson to context/lessons.md (or a cross-project preference to ~/.context-forge/preferences.md with approval), keeps both within budget, and promotes recurring lessons into the real context files.
forge-office
This skill should be used to open, stop, or configure the bundled forge-office dashboard — phrases like "forge-office", "open the dashboard", "show the office", "start the kanban board", "stop the dashboard", or "start the dashboard automatically". It launches the plugin's local web dashboard (kanban from the progress tracker, live agent office with realtime speech bubbles, activity feed, chat-to-session, assign-from-kanban) for the current project, and can enable autostart so it runs with every session.
forge-pr
This skill should be used to close out a completed unit with git in a Context Forge Methodology project — phrases like "forge-pr", "open a PR for this unit", "ship this unit", "commit and push", or "close unit NN". It creates the branch, makes a conventional commit, and opens a pull request with a spec-derived summary.
forge-prompt
This skill should be used to sharpen a rough or vague request into a high-quality, context-aligned prompt before acting on it — phrases like "forge-prompt", "optimize this prompt", "refine my request", "make this prompt better", "turn this into a proper prompt", or "what's the best way to ask for this". It clarifies intent, grounds the request in the project's context files, and outputs a sharp prompt or spec the user confirms — it never silently changes what the user meant.
forge-reconcile
This skill should be used to detect and adopt work done OUTSIDE the Context Forge process — phrases like "forge-reconcile", "someone committed without the process", "changes bypassed the workflow", "adopt these manual changes", "there are commits not in the tracker", or "bring out-of-band work back into the process". It finds commits with no unit/spec trail, analyzes them via the forge-scout agent, and — with approval — adopts each group as a retroactive spec plus tracker entry, so no work stays invisible to future sessions. Distinct from forge-audit (docs vs code content drift): this reconciles the PROCESS trail (git history vs tracker/specs).
forge-resume
This skill should be used at the start of a work session on a project that uses the Context Forge methodology — phrases like "forge-resume", "resume the project", "where did we leave off", "pick up where we stopped", "restore context", or "read the context files and continue". It restores project context tier by tier (digest and tracker first, full files only as the task requires) so work continues without drift and without burning tokens.
forge-review
This skill should be used to run a comprehensive, multi-lens code review of a pull request, a branch, or the local working changes in a Context Forge methodology project — phrases like "forge-review", "review this PR", "review my diff", "review the branch before I push", or "review PR 42". It resolves the review scope, loads the project's context files, builds a mechanical inventory of the diff, reviews across quality lenses (spec, standards, tests, errors, types, comments, simplicity) with per-item coverage tracked in a persistent review ledger, gates on confidence, and reports findings ranked by severity. With --until-clean it loops review → fix → re-review until one full pass finds nothing. Read-only — reviews and reports, never fixes.
forge-spec
This skill should be used for spec-driven development on a project that uses the Context Forge methodology — phrases like "forge-spec", "create a build plan", "break this into units", "write a spec for this feature", "generate a spec file", or "plan the build". It decomposes a project into ordered, verifiable build units and writes detailed per-feature spec files into context/specs/ that a coding agent implements exactly.
forge-verify
This skill should be used to verify a build unit before closing it in a project that uses the Context Forge methodology — phrases like "forge-verify", "verify this unit", "check the unit is done", "run the verification checklist", or "review before I close this". It runs the spec's verification checklist plus build/typecheck/lint and an adversarial review, then reports pass/fail.
forge-worktree
This skill should be used to run Context Forge builds in parallel across terminals — phrases like "forge-worktree", "build units in parallel", "work on two specs at once", "open another build in a new terminal", "claim unit 7", or "clean up the worktree". One unit = one git worktree = one branch = one terminal: it checks the unit is dependency-ready, claims it atomically (visible across all worktrees), creates the worktree, and hands the user the exact commands for the new terminal. Also lists claims and releases finished ones.
forge-migrate
This skill should be used to move a project's context directory from context/ to .forge/ — phrases like "forge-migrate", "migrate to .forge", "move the context dir to .forge", "move my context dir", "hide the context folder", or "my framework needs the context folder". It previews the migration, confirms, runs the bundled script (git mv with history, entry-point path rewrite, .gitignore guard), and offers the commit.
Bio shown is the top-scored skill's repo description as a fallback — real GitHub bios land in a future update.