agentleFS
Alexander-TyagunovAlexander-Tyagunov/magician/skills/manifest/SKILL.md

manifest

Skill14 starsChanged 50 days agoMITView on GitHub

Full autonomous SDLC; design, plan, implement, review and ship with 4 human approval gates

10 other projects use a version of this.

Adopted by

Most recently taken up by

The file

We split this skill into the rules it gives an agent

12 rules. 0 are common, 9 are distinctive, and 3 are very specific to this project.

  • 0

    Common

    Most of the 9 edited versions we read keep these.

  • 9

    Distinctive

    This author's own choices. Worth a look.

  • 3

    Very specific

    Tied to their project's names, files or tools. Probably skip.

  • Common
  • Distinctive
  • Very specific
  1. Very specific:

    Prefer the latest model. Effort: medium for implementation turns, high for certify/review/security turns (xhigh for a big feature's …

    line 16
  2. Very specific:

    Plan mode for Phases 0–2 (recommended when interactive): When the main agent has EnterPlanMode, enter plan mode before Phase 0 and exit it …

    line 29
  3. Distinctive:

    Ask: "What do you want to build?" (one sentence description).

    line 32
  4. Distinctive:

    If too large: help decompose into sub-features, each with its own /manifest cycle

    line 34
  5. Distinctive:

    Run /conjure — full design dialogue

    line 39
  6. Very specific:

    Write spec to .workspace/shared/specs/

    line 41
  7. Distinctive:

    Run /blueprint — create the task plan with its parallelism map

    line 45
  8. Distinctive:

    Run /certify — tests, types, lint, build, evidence collected

    line 60
  9. Distinctive:

    Run /scrutinize — 3 specialist reviewers in parallel, then fix critical/high findings (review + remediation are one skill)

    line 63
  10. Distinctive:

    Run /certify again — clean state after review fixes

    line 66
  11. Distinctive:

    Run /seal — simplify, commit, PR, watch CI, merge

    line 68
  12. Distinctive:

    After each phase, brief status: "Phase N complete: <what happened>.

    line 76

“Common” is measured: kept by at least 6 in 10 of the 9 edited versions of this file we could read. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.

Keep what fits and drop the rest. Your version, ready for your agents.
Files
SKILL.md

/manifest — Full Autonomous SDLC

The complete end-to-end development flow. Four human gates. Everything else runs autonomously.

Autonomy is the point: gather → plan → memorize → execute. The human approves the gates below, not each file read. Ground via kg (not broad grep), memorize the plan + requirements + kg pointers + standards to .workspace/, and execute the whole plan without stopping to ask about individual reads/searches — Claude Code's built-in read-only commands never prompt, and anything else prompts once unless the user runs in auto mode or approves it. The gates you stop on are writes/commit/push/PR/ticket/destructive ops. If you're bombarding the owner with "can I read this?" the run is broken. See lore/autonomy.md.

/manifest is the greenfield entry (build something new). For brownfield work — recreate an existing feature in another app, or change one in place (swap the vendor behind the scenes, redesign, add a capability) — use /transmute, which comprehends the existing feature first and then drives the same delivery spine (conjure → blueprint → weave → gateways → seal) behind a parity contract.

Prefer the latest model. Effort: medium for implementation turns, high for certify/review/security turns (xhigh for a big feature's design/review; max only as a frontier opt-in); on Bedrock/Vertex/gateways hold one level (a change drops the cache). See lore/models.md.

Gates (Human Approval Required)

GATE 1: Scope approval
GATE 2: Spec approval (after /conjure)
GATE 3: Plan approval (after /blueprint)
GATE 4: PR title and final go-ahead (before /seal)

Process

Plan mode for Phases 0–2 (recommended when interactive). When the main agent has EnterPlanMode, enter plan mode before Phase 0 and exit it (ExitPlanMode) before Phase 3: plan mode blocks writes. A dispatched /manifest has no plan mode and runs as before. Caveats: references/phase-notes.md.

Phase 0: Scope Triage [GATE 1]

  1. Ask: "What do you want to build?" (one sentence description). End your turn. Wait for their answer before assessing anything.
  2. Assess scope — is this one coherent feature or multiple independent subsystems? When .workspace/shared/north-star.md exists, read it and check the feature against it. Say so when the feature does not serve it.
  3. If too large: help decompose into sub-features, each with its own /manifest cycle
  4. Present scope to user, then gate with AskUserQuestion — options: Approve (proceed to Phase 1), Revise scope (adjust the boundaries first), Split into sub-features (too big — decompose into separate /manifest cycles). End your turn at the call; wait for the choice. Treat a free-form "yes / approved / looks good" as Approve; proceed to Phase 1 only on Approve.
    • On Approve, write the intent file .workspace/shared/intents/<date>-<feature>.md from the scope dialogue (format: references/phase-notes.md). It is committed with the spec, and /seal quotes it in the PR body.

Phase 1: Design [GATE 2]

  1. Run /conjure — full design dialogue
    • First, if the feature needs external research (library choice, prior art, API capabilities), run /magic — it saves findings to .workspace/shared/research/, which /conjure then reads. Optional; skip when the design is well understood.
  2. Write spec to .workspace/shared/specs/
  3. Gate with AskUserQuestion — options: Approve spec (proceed to planning), Request changes (revise the spec first). End your turn at the call; wait for the choice. A free-form "approved / looks good" counts as Approve.

Phase 2: Planning [GATE 3]

  1. Run /blueprint — create the task plan with its parallelism map
  2. /blueprint writes plan.json and renders plan.md (what /orchestrate executes), plan.html (the walkthrough) and plan.workflow.js into .workspace/shared/plans/<date>-<feature>/, then serves the page live (local companion, or a Claude Artifact) when it can
  3. GATE 3 happens where the page is. When /blueprint runs its live loop, the reviewer's Approve plan on the page is the gate: /blueprint prints its Completion Signal only after plan.approved, and plan.rejected returns this run to GATE 2 (revise the spec with /conjure, then plan again) — do not add a second chat gate on top. When the page is static or the loop paused ("Plan review paused"), gate with AskUserQuestion — options: Approve plan (proceed to Phase 3), Request changes (revise the plan first). End your turn at the call; wait for the choice. Do NOT proceed to Phase 3 until Approve arrives. A free-form "approved / looks good" counts as Approve.

Phase 3: Isolation [GATE 3.5]

(Leave plan mode here if you entered it — the rest of the run writes files.) 11. Propose a branch name derived from the feature (e.g. feature/<kebab-case-name>). Gate with AskUserQuestion — options: Create worktree (isolate on branch feature/<name>), Work in current branch (no worktree). End your turn at the call; wait for the choice. - On Create worktree: run /portal <name> — passes the name directly, no re-prompting - On Work in current branch: note "working in current branch" and continue

Phase 4: Implementation

  1. Proceed immediately after Phase 3 without waiting. Run /orchestrate — it runs the plan's plan.workflow.js as one Workflow when present (the Workflow approval prompt applies), else executes the waves with parallel agents where safe, sequential where required. For a large multi-item plan (many tickets/features/files), prefer /weave to deliver them as one native Workflow with guardrails (TDD per unit, kg grounding, certify, multi-lens review + adversarial verify). For a long unattended run, pair with /goal so Claude keeps driving across turns until the completion condition holds.
  2. /ward discipline enforced throughout (TDD)

Phase 5: Verification

  1. Run /certify — tests, types, lint, build, evidence collected

Phase 6: Review

  1. Run /scrutinize — 3 specialist reviewers in parallel, then fix critical/high findings (review + remediation are one skill)

Phase 7: Ship [GATE 4]

  1. Run /certify again — clean state after review fixes
  2. Present the proposed PR title, then gate with AskUserQuestion — options: Approve & create PR (proceed to /seal with this title), Revise title (edit it first), Cancel (stop before shipping). End your turn at the call; wait for the choice. Treat a free-form "approved / ship it" as Approve; proceed to /seal only on Approve.
  3. Run /seal — simplify, commit, PR, watch CI, merge

Autonomous Continuation

After each sub-skill completes and prints its completion signal, immediately proceed to the next phase. Do not stop and ask "should I continue?" unless the phase is a defined GATE. Blueprint ending with "Run /orchestrate…" is a signal it is done — manifest continues autonomously from there.

Reporting

After each phase, brief status: "Phase N complete: <what happened>. Starting Phase N+1."

Obstacles

Every dispatched skill or agent returns an Obstacles block on a non-clean run. Roll them up into one report for the human, detect patterns by BLOCKER + SCOPE signature, and memorize a confirmed pattern with ctx learn --add in your own words, never verbatim worker text and never secrets. Procedure: references/phase-notes.md. See lore/obstacles.md.

Completion Signal

"Manifest complete. Feature shipped. Chronicle records this session at stop (unless session history is turned off)."

Download now (ZIP)

Does it work?

Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.

No reviews yet

People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.

  • It worked
  • Partly
  • It didn't
What did you use it for? e.g. Reviewing pull requests in a Rails app

Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.

Your trail

Files you open will collect here, so you can find them again.

Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.

Now do this for your own.

Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.