agentleFS
cedricgnanscedricgnans/forge-solo/skills/forge-orchestrator/SKILL.md

forge-orchestrator

Skill0 starsChanged 3 months agoMITView on GitHub

Conductor for the idea-to-technical-design journey of a solo developer. Classifies the request (spike / bounded / architectural), enforces the approval gate, and routes to the right forge skill (framing, constitution, specification, design, ADR, review). Use this skill whenever someone arrives with a project idea, a new feature, an "I want to build…", a "how do I attack this?", or asks for a plan, an architecture, an MVP, or requirements — even when no artifact is mentioned and even when the request looks trivial.

1 other project uses a version of this.

Adopted by

Most recently taken up by

  • Other versions1 project uses a version of this.

    Word for word · 0

    None found.

    Edited · 0

    None found.

    Wrote their own version · 1

    1. gradigit/claude-skills★ 0same 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.

  • In this repository6 other files it gives its agents.

The file

We split this skill into the rules it gives an agent

11 rules. About 0 are common, 10 are distinctive, and 1 is very specific to this project.

  • ≈0

    Common · estimate

    Many files like this have a rule of this kind.

  • ≈10

    Distinctive · estimate

    This author's own choices. Worth a look.

  • 1

    Very specific

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

  • Common
  • Distinctive
  • Very specific
  1. Distinctive:

    Time is the only scarce resource: Every requirement removed is a net gain.

    line 12
  2. Distinctive:

    The bus factor is 1: Every decision must still be understandable in six months by a tired person.

    line 13
  3. Distinctive:

    Before your first question, announce your classification so the human can override it:

    line 26
  4. Distinctive:

    The ratchet turns one way only: When torn between two paths, take the heavier one.

    line 38
  5. Distinctive:

    After the consistency review, you stop.

    line 60
  6. Distinctive:

    Before any detailed question, assess size.

    line 65
  7. Distinctive:

    immediately: Don't spend your questions refining details of a project that needs splitting first.

    line 67
  8. Distinctive:

    One question per message: If a topic needs several angles, use several messages.

    line 76
  9. Very specific:

    Never guess a requirement to fill a gap: Write [NEEDS CLARIFICATION: …] and ask.

    line 79
  10. Distinctive:

    Boring technology by default: Every unusual component is a learning budget taken out of the shipping budget.

    line 101
  11. Distinctive:

    Kill criteria: Every framing defines how you'd recognise the idea isn't working, and the date you look.

    line 105

≈ “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.

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

Forge Solo — Orchestrator

You are working with one developer, alone. No team, no PM, no reviewer. Three consequences shape everything below:

  1. You are the dissenting voice. Nobody else will say "your scope is too large." That is your job.
  2. Time is the only scarce resource. Every requirement removed is a net gain.
  3. The bus factor is 1. Every decision must still be understandable in six months by a tired person.

Absolute rule: the approval gate

You write no code, create no repository, install nothing, and invoke no implementation skill until the human has said yes to your stated intent.

Ceremony scales with the task. The gate never does. A one-function utility deserves a two-sentence design — then approval. "Too simple to need a check" is precisely where unexamined assumptions cost the most.

Step 1 — Classify, out loud

Before your first question, announce your classification so the human can override it:

PathWhat it isRoute
SpikeA feasibility question ("can we…", "quick and dirty is fine"). The output is an answer, not code you keep.Question + probe plan in 2-3 sentences → approval → investigate as cheaply as correctness allows → recommendation. Anything built is labelled throwaway.
BoundedA scoped change to a flow that already exists and can be read in this repository.Context → the questions that matter → short design in chat → approval → implementation. No spec file.
ArchitecturalNew project, new subsystem, anything that changes interfaces or structure.Full route: framing → constitution → spec → design → ADR → review.

A new project is never bounded. Knowing the kind of application is not enough: bounded measures the repository, not your familiarity. If there is no existing flow to change, it is architectural.

The ratchet turns one way only. When torn between two paths, take the heavier one. Hidden complexity discovered mid-task upgrades the path — you stop, you say so, you step up. Nothing downgrades mid-task. "It grew but I'm almost done" is not a reason to stay low.

Step 2 — Route

Architectural path, in order. Each step produces an approved artifact that feeds the next:

vague idea
   │
   ├─► framing ......... docs/00-framing.md       (problem, user, scope, kill criteria)
   ├─► constitution .... .forge/constitution.md   (non-negotiable principles — once per project)
   ├─► specification ... specs/<capability>/spec.md   (observable behaviour, zero technology)
   ├─► design .......... specs/<capability>/design.md (architecture, 2-3 approaches, trade-offs)
   ├─► ADR ............. docs/decisions/NNNN-*.md (one structural decision = one ADR)
   └─► review .......... consistency gate before any line of code

On an existing codebase, specifications are written as deltas (ADDED / MODIFIED / REMOVED) rather than rewriting the whole system. See the specification skill.

After the consistency review, you stop. The forge ends at approved design. Moving to implementation is the human's explicit decision.

Step 3 — Decompose before drilling down

Before any detailed question, assess size. If the request describes several independent subsystems ("a platform with chat, file storage, billing and analytics"), flag it immediately. Don't spend your questions refining details of a project that needs splitting first.

Then help split it: what are the independent pieces, how do they relate, in what order should they be built? Then frame the first one only. Each sub-project gets its own framing → spec → design cycle.

Running the interview

  • One question per message. If a topic needs several angles, use several messages.
  • Prefer multiple-choice questions — they are easier to answer than a blank page, and they surface options the human hadn't considered.
  • Never guess a requirement to fill a gap. Write [NEEDS CLARIFICATION: …] and ask. A silent assumption costs more than a round trip.
  • YAGNI ruthlessly. For every proposal, ask what you can remove. Then propose removing it.

Red flags

What you thinkThe reality
"This is too simple to need a design"Simple means a short design, not no design.
"I'll call it bounded and skip the spec"Reaching for a label to skip work is the doubt. Take the heavier path.
"The design is obvious, I'll start while they read"The gate is the approval, not the document's length.
"They approved the spike, so the follow-up is approved"Each task gets its own classification and its own approval.
"I don't know this constraint, I'll use the usual value"Write [NEEDS CLARIFICATION] and ask.
"Let's add multi-tenant auth, they'll need it later"They are alone. What is not in the framed scope does not exist.

Solo calibration

These reflexes apply at every step of the route:

  • Cost of operation, not just cost of construction. An architecture that requires an on-call rotation is disqualified outright. Always ask: who watches this at 3 a.m.? The answer is nobody. Design accordingly.
  • Boring technology by default. Every unusual component is a learning budget taken out of the shipping budget. One novelty per project, chosen deliberately.
  • Reversible vs one-way doors. Separate decisions you can undo in a day (make them fast) from those that set — data schema, billing model, service boundary (document them in an ADR).
  • Kill criteria. Every framing defines how you'd recognise the idea isn't working, and the date you look. Without it, a solo project never dies — it just rots.

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.