dev-all
Skill68 starsChanged 4 months agoMITView on GitHub
Orchestrate the /dev methodology across ALL phases of a feature spec via a background ultracode run, one fresh agent per bounded (sub-)phase, sequentially. Handles the DB migration itself, splits oversized phases, monitors progress, recovers from agent overruns, independently certifies each block, and reconciles the spec. Encodes the failure modes seen in practice so they do not recur.
1 other project uses a version of this.
Adopted by
Most recently taken up by
- rioX432/agent-witnesstheir own version, first seen Jul 2, 2026
Other versions1 project uses a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 1
- rioX432/agent-witness★ 1same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
The file
We split this skill into the rules it gives an agent
11 rules. About 0 are common, 3 are distinctive, and 8 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈3
Distinctive · estimate
This author's own choices. Worth a look.
8
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Distinctive: line 30
Nothing gets committed: Leave everything in the working tree for the user's review.
- Very specific: line 37
Read spec. Enumerate every phase and its checklist items.
- Very specific: line 38
Read .claude/skills/dev/SKILL.md once to stay faithful to the /dev methodology (explore -> implement+tests -> verify -> tick spec).
- Very specific: line 41
If the spec defines a migration: write the SQL file into your migrations directory (e.g.
- Very specific: line 43
Only if env=dev+prod: apply to prod (project your_prod_project_id), otherwise leave prod as an explicit TODO.
- Very specific: line 46
Verify the spec's "files to modify" anchors actually exist.
- Very specific: line 61
Start a persistent Monitor on the run's journal.jsonl (under the transcript dir printed by Workflow) that emits one line per new …
- Very specific: line 64
After the last backend sub-phase (and again at the very end), run YOURSELF: cd backend && go build ./...
- Very specific: line 68
Stop the run: if it is looping (TaskStop).
- Distinctive: line 71
If the tree is genuinely broken: either fix the small breakage yourself (only when no agent is running) or clean up and re-run that phase …
- Distinctive: line 75
Run the full gates yourself (Step 6) and the project's config-sync check (if it has one).
≈ “Common” is an estimate: at least 1 in 5 of the 372,429 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
YOU ARE EXECUTING THE /dev-all SKILL. The user triggered this skill. Follow ALL instructions below step by step. Do NOT treat this as a freeform conversation - execute the runbook.
Follow CLAUDE.md rules.
This skill runs a whole *_FEATURE.md-style spec to "done & green", phase by phase, with the user doing only the final review. You are the orchestrator: you author and launch a background ultracode run that runs each phase as a separate fresh agent, you monitor it, you recover when an agent overruns, and you independently certify the result (never trust an agent's self-reported build=pass). You do NOT hand-write the feature code; its agents do.
Arguments
spec=<path>(required): the feature spec, e.g.docs/plan-features/YOUR_FEATURE.md.from=<phase>/to=<phase>(optional): run a sub-range (e.g. resumefrom=6). Default: all phases.env=dev|dev+prod(optional): where to apply migrations. Defaultdev(dev only; never prod unless explicitly asked).
Golden rules (these prevent the failures listed at the bottom)
- YOU own migrations, not the agents. Apply to DEV up front, save the file, then tell every agent "migration already applied, do not re-apply, do not touch prod."
- Split oversized phases into bounded sub-phases. A single agent has a finite turn/token budget. Any phase that touches more than ~3 files of real code, or says "all N clients/providers", or "several usecases", MUST be split so each agent does ~2-3 files + tests. This is the #1 lever.
- Sequential, fresh context each.
awaiteach (sub-)phase before the next; later phases see earlier edits on disk. Never parallelize interdependent phases. - Trust nothing's
build=pass. Agents sometimes report green from a stale build. After each backend block and at the very end, run the gates YOURSELF. - Never edit files while the ultracode run is live. Concurrent edits race with a live agent and create confusing half-states. Stop the run first, or wait for the phase to finish.
- A returned partial beats a dead agent. Bake "return-discipline" into the prompt and wrap each
agent()in try/catch so an overrun stops the run cleanly instead of looping. - Nothing gets committed. Leave everything in the working tree for the user's review.
Runbook
Step 0: Read the spec, plan the phases
- Read
spec. Enumerate every phase and its checklist items. Note per phase: scope (backend / frontend), files to create/modify, and which numbered phase each maps to. - Read
.claude/skills/dev/SKILL.mdonce to stay faithful to the /dev methodology (explore -> implement+tests -> verify -> tick spec).
Step 1: Migration FIRST (you, not the agents)
- If the spec defines a migration: write the SQL file into your migrations directory (e.g.
migrations/<ts>_<name>.sql), matching the format of a recent sibling migration, with a header comment noting DEV-applied + PROD-deferred. - Apply to dev via your DB MCP server's
apply_migrationtool (dev projectyour_dev_project_id). Verify the column/table withexecute_sql. Runget_advisors(security) and confirm no NEW findings from your change. - Only if
env=dev+prod: apply to prod (projectyour_prod_project_id), otherwise leave prod as an explicit TODO.
Step 2: Pre-flight (cheap, high-value)
- Verify the spec's "files to modify" anchors actually exist; locate any that are mis-referenced (e.g. a port defined inline in a usecase rather than under
ports/). Capture these as per-phase hints, they save the agent a wrong turn. - Confirm the baseline is green (
cd backend && go build ./...;npm run -s -C frontend test:runif quick) so any later red is attributable to the work, not the starting point.
Step 3: Split oversized phases
- Decide the sub-phase list. Typical splits that proved necessary:
- "Application usecases" (builder + several new usecases + scheduler) ->
6abuilder+first usecase,6bsecond usecase,6cthird usecase,6dscheduler+config. - "Presentation + wiring" ->
7ahandlers/DTOs,7broutes + DI wiring. - "Multiple external client integrations" -> one sub-phase per ~2 clients + their config/tests.
- "Application usecases" (builder + several new usecases + scheduler) ->
- Assign each config key to its first consumer sub-phase (that sub-phase adds it to
app.yaml+ the config struct + runs the project's config-sync step if it has one; later phases just verify). This avoids "phase 5 needs a key phase 7 was supposed to add".
Step 4: Author and launch the ultracode run
- Copy
.claude/skills/dev-all/templates/workflow-template.js. Edit the 5 marked sections:meta.phases,PHASE_TITLES,SPEC,PRIOR_DONE,PHASES(+ per-phasehints). Backend ->golang-backend-developer, frontend ->frontend-feature-developer. - Launch with the
Workflowtool (inlinescript, orscriptPathafter editing the file). It runs in the background and notifies you on completion/stop.
Step 5: Monitor
- Start a persistent
Monitoron the run'sjournal.jsonl(under the transcript dir printed by Workflow) that emits one line per new"type":"result"entry. Relay each (sub-)phase result to the user;PushNotificationonly on a block.
Step 6: Independent certification per block
- After the last backend sub-phase (and again at the very end), run YOURSELF:
cd backend && go build ./... && go vet ./... && golangci-lint run ./internal/... && go test ./.... For frontend:cd frontend && npm run test:run && npm run build. These, not the agents' self-reports, are the source of truth. - Frontend phases never touch Go, so you can run Go gates while frontend phases run (no collision). Do NOT run Go-file edits while a backend phase is live.
Step 7: Recovery playbook (when a phase blocks or the run stops)
- Stop the run if it is looping (
TaskStop). Read the run'sjournal.jsonl(NOT the multi-hundred-KB agent*.jsonltranscripts) to see what each phase reported. - Inspect the working tree:
git status --short;go build ./...;go vet ./internal/.../...; grep for the methods/files the phase was supposed to produce. - Most overruns left the work DONE on disk (the agent just ran out of turns before calling StructuredOutput). If
build/vet/test/lintare green and the deliverables are present: tick the spec boxes for that phase yourself and continue with the remaining phases (a fresh ultracode run whosePRIOR_DONEincludes the recovered phase), do not re-run it. - If the tree is genuinely broken: either fix the small breakage yourself (only when no agent is running) or clean up and re-run that phase split smaller.
- Resuming:
resumeFromRunIdre-runs only the first non-cachedagent()onward, but it cannot "skip" a phase that never returned a cached result, so for recovered phases prefer a new ultracode run covering just the remaining phases (setPRIOR_DONEaccordingly).
Step 8: Final certification + reconcile + report (no commit)
- Run the full gates yourself (Step 6) and the project's config-sync check (if it has one).
- i18n em-dash scan: confirm the spec's NEW i18n keys and any new frontend files contain no em-dashes (
U+2014) or en-dashes (U+2013); fix only NEW occurrences (do not churn pre-existing ones). Tip:python3scan for those two codepoints. - Reconcile the spec's Execution Plan: tick the phase-summary lines and the verification commands you actually ran; annotate deferred items (prod migration, manual owner steps) honestly.
- Report: what shipped, the certified gate results, what you did vs the agents, and what remains (prod migration, manual/owner actions, E2E QA). Do NOT commit, offer to commit/PR on request.
Problems encountered in practice (and how this skill avoids each)
These are real failures from a full run of this orchestration. The template + runbook above encode the fixes.
| # | Problem observed | Root cause | Fix encoded here |
| 1 | Ultracode run crashed instantly: ReferenceError: meta is not defined | The export const meta literal is NOT in scope in the script body. | Template uses a local PHASE_TITLES array; never reference meta.* in the body. |
| 2 | A big phase (5-6 clients + tests) ran ~21 min, hit its turn budget, errored without returning, and the ultracode run retried it 3x in a loop, each retry inheriting a half-edited tree. | One agent given too much work; a thrown agent() with no guard gets retried indefinitely. | (a) Split oversized phases into bounded sub-phases; (b) return-discipline prompt (return a partial, never run to death); (c) try/catch around each agent() so a throw STOPS the run cleanly. |
| 3 | Another big phase did all the work (100+ tool calls) but never called StructuredOutput -> error. | Same budget overrun, just after finishing. | Recovery insight in the runbook: the work is usually already on disk, verify green + tick boxes instead of re-running. Plus splitting prevents it. |
| 4 | An agent reported build=pass but had left a compile error (referenced a struct field it forgot to add). | Agents self-report from a stale build; the stop-on-block guard trusted the report. | Orchestrator runs independent go build/vet/test after each backend block and at the end. Never trust self-reported green for the final gate. |
| 5 | A transient broken-test diagnostic appeared mid-run (a constructor signature changed but its test not yet updated). | A file-edit race: reading/seeing the tree while an agent was mid-edit. | Rule: never edit (and distrust transient diagnostics of) the tree while the ultracode run is live. Stop first, or wait for the phase to finish, then verify the settled state. |
| 6 | A config key was needed by phase 5 but the spec "added" it in phase 7. | Cross-phase config dependency. | Assign each config key to its first consumer sub-phase, which adds it + runs the config-sync step; later phases only verify. |
| 7 | Risk of agents running DB migrations / hitting prod. | Migration left to a phase agent. | You apply the migration up front (DEV only by default), save the file, and tell every agent "already applied, do not re-apply, do not touch prod." |
| 8 | New test describe() labels used em-dashes (matching a pre-existing codebase convention), violating the hard rule. | Agents match surrounding code, which already breaks the rule. | Final em-dash scan on i18n + new files; fix only NEW occurrences; do not churn pre-existing ones. |
| 9 | When a phase was split or hand-recovered, the spec's Execution-Plan summary checkbox was left unticked. | No sub-agent owns the summary line. | Orchestrator reconciles spec checkboxes in Step 8. |
| 10 | go test ./... recompiles the whole module; agents re-running it after every edit burned their budget. | Inefficient verification loop. | Efficiency rule in the prompt: targeted tests during dev, full gate ONCE at the end. |
Notes
- Ultracode (dynamic multi-agent orchestration) requires explicit opt-in; this skill IS that opt-in (the user invoked it). Author the workflow script, launch it via the
Workflowtool, monitor, recover, certify. - Inspect the run via the printed
journal.jsonl, NOT the per-agent*.jsonltranscripts (those are huge and will flood context). - Phase agents MAY spawn their own exploration sub-agents (e.g.
Explore/explore-codebase) to parallelize discovery, one per distinct concern with no fixed cap. Encouraged on larger sub-phases: it keeps the phase agent's own context lean (it gets summaries back instead of reading everything inline), which directly mitigates the budget-overrun failure mode. Inline Grep/Glob/Read stays fine for a small sub-phase. Make sure each phase agent knows it has this option. - DB projects: dev
your_dev_project_id; prodyour_prod_project_id(only withenv=dev+prod). Replace these placeholders with your actual project IDs and MCP tool names.
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
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.

