Skip to content
Skills Library
Programming · Building & coding

forge

/forge

Run a code-modifying request end to end, with pipeline depth proportioned to the change - triage scores its size and risk, and those two dials decide plan, challenge, tests, and how deep the review wave runs. Use for any request that changes project code or config - features, fixes, refactors, even small or mechanical ones - instead of editing inline. Skip when your own prompt names a run dir and a brief to follow: you are inside a forge run, and the pipeline never re-enters itself.

Author
alp82 ↗
Repository
forge ↗
Licence
MIT
Last repository change
26.07.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
13
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 26.07.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

Run a code-modifying request end to end, with pipeline depth proportioned to the change - triage scores its size and risk, and those two dials decide plan, challenge, tests, and how deep the review wave runs. Use for any request that changes project code or config - features, fixes, refactors, even small or mechanical ones - instead of editing inline. Skip when your own prompt names a run dir and a brief to follow: you are inside a forge run, and the pipeline never re-enters itself.

Arguments

/forge the request, or a tracker ticket reference
Original author description

Run a code-modifying request end to end, with pipeline depth proportioned to the change - triage scores its size and risk, and those two dials decide plan, challenge, tests, and how deep the review wave runs. Use for any request that changes project code or config - features, fixes, refactors, even small or mechanical ones - instead of editing inline. Skip when your own prompt names a run dir and a brief to follow: you are inside a forge run, and the pipeline never re-enters itself.

How it works

  1. Open the run
  2. Triage
  3. Plan
  4. Challenge
  5. Tests
  6. Implement
  7. Review wave
  8. Fix
  9. Close
  10. Standing stances
Original SKILL.md headings · 79 lines, 1,465 words
SKILL.md preview
---
name: forge
description: Run a code-modifying request end to end, with pipeline depth proportioned to the change - triage scores its size and risk, and those two dials decide plan, challenge, tests, and how deep the review wave runs. Use for any request that changes project code or config - features, fixes, refactors, even small or mechanical ones - instead of editing inline. Skip when your own prompt names a run dir and a brief to follow: you are inside a forge run, and the pipeline never re-enters itself.
argument-hint: the request, or a tracker ticket reference
---

# forge — the pipeline router

You are the orchestrator of one forge run. Every stage runs as a spawned subagent reading a sibling brief file; you spawn, gate, and relay — you never do a stage's work inline. The conversation carries only gists and terse status lines (`<stage> done ▶ <next>`); full sentences are reserved for findings, errors, and points where the user must decide.

**Enforcement self-check.** Once, before triage, look for any evidence of the adapter's enforcement layer — the cheapest signal the harness offers: injected session context (a forge banner or equivalent) or the adapter's hooks registered in the harness. Any single piece of evidence suffices; say nothing when one is found. Only when there is none, tell the user plainly: this run is prose-only, every rule in this brief binds regardless, and the adapter's README/setup restores the native install.

**Spawn contract.** One shape for every stage: spawn a fresh isolated agent (`read-only` where marked) with the tier the step names, and the prompt: *"Read `<brief path>` and follow it. Run dir: `<run dir>`. Inputs: `<paths>`."* A tier resolves to a concrete model through the adapter's `models` manifest; absent a manifest, map the four tiers — `mini`, `standard`, `large`, `ultra` — onto the harness's available models in ascending capability. Paths, never pasted content — every artifact a later stage consumes is a file in the run dir, so a fresh respawn needs only paths. Brief paths are relative to this skill's base directory; crossfire lens briefs sit beside it at `../crossfire/`. The worker forwarder (`WORKER.md`) takes one extra prompt field — `host-vendor: <vendor>`, read verbatim from the session-start banner's host-vendor line — so it can exclude same-vendor second opinions; if no banner carries that line, forward nothing and the worker fails loud to single-model judgment (its brief owns that rule).

## Open the run

1. Ensure `.forge/` is in the repo's `.gitignore`; append it if missing.
2. Create the run dir `.forge/<slug>/` — a short kebab-case reduction of the request subject (≤40 chars).
3. **Ticket contract.** When the request is or names a tracker ticket, read it per `docs/agents/issue-tracker.md` — the ticket body is the request. At close, post a resolution comment (verdict gist, pointer to the change's durable home — commit or PR, explicit deviations) and close the ticket. No tracker configured → the contract lies dormant.

## Triage

Spawn TRIAGE.md (`read-only`, tier `mini`) → writes `intent.md`, returns provisional SIZE and RISK bands plus flags. The dials are separable - **SIZE gates the artifacts (plan, tests), RISK gates the adversaries (challenge, worker)** - and every gate below names the dial it reads. Take each detour whose flag fired — conditions, not stages; skip silently otherwise:

- **unknowns** → follow INTERVIEW.md yourself, inline — it questions the user, and a subagent can't. Never answer its questions on the user's behalf.
- **unproven external** → PROTOTYPE.md (build spawned, reaction with the user) → `prototype.md`.
- **missing knowledge** → spawn RESEARCH.md (tier `standard`) → `research.md`.
- **bug** → spawn DIAGNOSE.md (`read-only`, tier `large`) → `diagnosis.md`. A bug is a code build with a diagnosis first, never its own route.
- **multi-session** — the ask spans sessions with open decisions → recommend charting a map with a mapping skill such as `/wayfinder`; with none available, the interview carves the largest one-session slice and names the remainder.

**Short path - Gate:** SIZE `minimal` AND RISK `routine` - skip plan, challenge, and tests: spawn IMPLEMENTER.md (tier `ultra`) straight off `intent.md`, then the review wave. This corner has no re-score; triage's provisional bands stand.

## Plan

**Gate:** plan depth is the deeper of the SIZE lookup - `minimal` skip, `moderate` light, `substantial` full - and the RISK floor: `elevated` or `critical` floors it at light, because a challenge needs a plan to challenge.

Spawn PLANNER.md (tier `ultra`) → `plan.md`; at light, add one prompt field - `plan-depth: light` (PLANNER.md defines it). Its RETURN re-scores SIZE and RISK authoritatively: the planner is the single writer of both bands; the re-score replaces triage's provisional call for every gate below, and across any later re-spawn a band only ratchets up - keep the higher. A `DETOUR: prototype` return means a load-bearing external couldn't be verified from sources — take the prototype detour, then re-spawn.

## Challenge

**Gate:** RISK `routine` skips this stage; `elevated` runs the challenger alone, autonomously; `critical` runs challenger + worker with the user's gate. When `challenge.md` lands, write the empty marker `challenge-ran` to the run dir.

- `elevated` - spawn CHALLENGER.md (tier `ultra`) → `challenge.md`, then act on its VERDICT: `approve` → proceed; `revise` → re-spawn PLANNER.md with the BLOCKERS as corrections, consuming one of two rounds - still blocked after two, put the standing blocker to the user as Approve / Revise / Reshape; `reject` → the plan answers the wrong question - straight to the user and the interview, no round consumed. Each revise pass re-reads the re-spawned planner's ratcheted RISK: a mid-loop re-score to `critical` runs that pass at the `critical` tier below - worker and user gate included.
- `critical` - spawn in parallel, neither seeing the other's verdict before both are written: CHALLENGER.md (tier `ultra`) → `challenge.md`, and the worker forwarder WORKER.md (tier `standard`) → `challenge-worker.md` - a different-model second opinion; on failure it records `WORKER FAILED`, visible and non-blocking. Read both, then put a structured choice to the user: **Approve** (proceed; open concerns become known risks) / **Revise** (re-spawn PLANNER.md with the blockers as corrections; the revised plan re-earns approval through this gate) / **Reshape** (back to the interview - the plan answers the wrong question). The plan's Summary and both challenge verdicts are the evidence shown.

## Tests

**Gate:** the change carries real logic - triage's NEEDS-TESTS, or the plan reveals it.

One stage, two hands — like the challenge, it pairs a doer with an independent check:

1. Spawn TEST-AUTHOR.md (tier `standard`) → red tests in the repo's test tree + `tests.md`.
2. Spawn TEST-REVIEW.md (`read-only`, tier `large`) to validate the red tests against intent and plan. `misaligned` → re-spawn TEST-AUTHOR.md with the report; loop until `ready`. Code never starts against unvalidated tests.

## Implement

Spawn IMPLEMENTER.md (tier `ultra`) → the change with tests green + `receipt.md`. A KICKBACK return (its brief names the kickback levels) → re-spawn PLANNER.md with the reason as corrections - its re-score may raise a band, never lower one - then re-run the implementer: a forward correction, no re-gate through the challenge, with one exception - when the re-score lands RISK `critical` and no `challenge-ran` marker exists in the run dir, run the Challenge stage at `critical` before the implementer. The re-fired challenge writes the marker, so the rewind cannot fire twice - once per run by construction. Two kickbacks on the same blocker → stop and surface to the user.

## Review wave

**Gate:** the wave always fires; membership keys on the re-scored bands - triage's provisional bands when no plan ran.

Spawn every applicable lens in parallel, each reading `receipt.md` + `plan.md` + `intent.md`, each writing `findings-<lens>.md`:

- **Floor, every build:** `../crossfire/CORRECTNESS.md` (tier `large`), `ACCEPTANCE.md` (`large`).
- SIZE `moderate` and up adds `SIMPLICITY.md` (`standard`) + `CONVENTIONS.md` (`standard`); `substantial` adds `SHAPE.md` (`standard`).
- RISK `critical` adds the WORKER.md forwarder over the diff → `findings-worker.md` - one more lens, same visible-failure rule.
- **Conditional, surface-triggered on any band:** `UI.md` (`standard`) when the diff touches user-facing UI; `SECURITY.md` (`large`) when it touches auth, secrets, permissions, or untrusted input; `PERFORMANCE.md` (`large`) when it touches a hot path or data-volume-sensitive code.

**Backstop.** Before you read a single verdict, any lens missing its file from the run dir gets it written by you off the text that lens returned - the stop gate settles on `findings-*.md`, so a text-only return leaves the debt open.

## Fix

**Gate:** any lens failed. Spawn FIXER.md (tier `standard`; `ultra` when the fix set is large or structural) with the findings paths. It fixes and returns a re-run set: re-spawn exactly those lenses (CORRECTNESS always rides along) over the new diff. Loop until every lens is clean. Findings the fixer can't own (plan-level, missing context) surface to the user — never silently dropped.

## Close

Terse summary: what changed and where, review outcome, deviations from the plan. Post the ticket resolution when one is open. Run artifacts are process debris — they die with the run; reasoning worth keeping goes to a repo-native home (docs, ADR, commit message) and gets pointed at. Stamped code changes owe tests and review before the session ends; the adapter's stop-gate, where present, enforces that floor.

## Standing stances

- **Confirm before remote.** No push, publish, or PR creation without an explicit user confirm; the adapter's tool guard, where present, backs this deterministically.
- **Confirm before destruction.** Destructive or irreversible commands are proposed to the user, never run unconfirmed.
Files in this package (13)
  • CHALLENGER.md 3 KB
  • DIAGNOSE.md 4 KB
  • FIXER.md 1 KB
  • IMPLEMENTER.md 3 KB
  • INTERVIEW.md 3 KB
  • PLANNER.md 5 KB
  • PROTOTYPE.md 3 KB
  • RESEARCH.md 2 KB
  • SKILL.md 10 KB
  • TEST-AUTHOR.md 2 KB
  • TEST-REVIEW.md 1 KB
  • TRIAGE.md 4 KB
  • WORKER.md 7 KB

Versions

RepositoryScoreLicence
This page · alp82/forge90MIT
aimi-so/aimi-engineering-plugin100MIT
claudemods/context-forge100MIT
cwinvestments/memstack100MIT
MohammedAtya/guardrail-forge100MIT
faizanio/FORGE100MIT
thecrazybob/claude-code-plugins100MIT
floka-as/floka-marketplace100MIT

Database snapshot: 13.11.2026 · package version 9be1c7b60364 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90crossfire
    Fire forge's multi-lens review wave - parallel independent lenses plus a different-model worker over one change. Use when a stop gate says a review wave is owed, or the user asks for crossfire or the review wave by name. Reviews of a branch, a PR, or changes since a commit…
  • 95forge-land
    Decide what a green pull request needs from a human: check it is mergeable, green, addressed and exercised, get a fresh-context risk verdict on the head commit, write it into the PR as a ## Risk section, and report merge-ready or review-ready. Merges a low-risk PR only when the…
  • 90contribute
    Take a change to character-forge-mcp from intent to pull request — an issue for the intent, a branch linked to it, develop with tests, refactor (/simplify), review (/code-review), and a PR that closes the issue on merge. Use when asked to implement, fix or change something in…
  • 100forge-ship
    End-to-end implementation and self-review in a single invocation — implements from an Issue, plan file, or free-text description, then runs a lean fresh-context review. With --guard it also waits for CI and peer review, addresses feedback until the PR is review-ready, and ends…
  • 100review
    Use when the user asks for a code review of a change, diff, branch, or PR, including a diff pasted inline and phrasings like "review this before I open the PR", "can you code review this?", or "look over this change". Auto-routes between a fast inline checklist (QUICK) and the…
  • 95forge-app-review
    Reviews Forge apps for security vulnerabilities, architecture issues, cost inefficiencies, performance problems, and trigger/scheduling waste before deployment. Use when the user says "review my Forge app", "check my app", "pre-deploy check", "is my app ready to deploy", "audit…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.