By skyforbes i rebuilt everything from scratch. strict formats. clear inputs. defined outputs. no ambiguity.
now i have 20+ agents that talk to each other and run fully autonomous. here's the lineup:
main agents:
- init – sets up branch, safety rails
- principal-analyst – analyzes specs ask user questions
- specifications-indexer – structures requirements
- blueprint-orchestrator – coordinates architecture phase
- planning-agent – generates full dev plan
- task-breakdown-agent – extracts tasks into json
- context-manager-agent – pulls relevant context per task
- code-generation-agent – writes the code
- task-validation-agent – verifies against acceptance criteria
- runtime-preparation-agent – generates shell scripts
architecture sub-agents:
- founder-architect – core foundation decisions
- structural-data-architect – schemas, ERDs, C4 diagrams
- behavior-architect – logic, state, interactions
- operational-architect – deployment, infra
- ui-ux-architect – components, layouts
- file-assembler – final file structure
workflows:
- git-commit-workflow
- task-verification-workflow
- iteration-verification-workflow
each agent has a strict prompt.md file. here's the skeleton they all follow:
the prompt structure (steal this):
// PROTOCOL: [AgentName]_v1.0
// DESCRIPTION: [One line — what this agent does]
1.0 ROLE & OBJECTIVE
- who u are
- what ur mission is
- what u focus on (and what u ignore)
2.0 INPUTS
- what u receive from previous agent
- reference docs u must follow
3.0 OUTPUT
- exact file name
- exact file path
- no ambiguity
4.0 CORE DIRECTIVES
- the rules u cannot break
- what to adhere to
- what to never assume
5.0 REQUIRED OUTPUT STRUCTURE
- the exact template u must follow
- section by section
- nothing left to interpretation
6.0 QUALITY GUIDELINES
- line count ranges by project size
- content distribution percentages
- minimum = incomplete, maximum = over-detailed
---
**why this works:**
1. **no role confusion** — the agent knows exactly what it is and isn't responsible for
2. **inputs are explicit** — it knows what it's receiving and from where
3. **outputs are strict** — exact file, exact path, exact format. no creativity where u don't want it
4. **guardrails built in** — core directives prevent drift and hallucination
5. **quality is measurable** — line count guidelines tell the agent when it's done
**how they talk to each other:**
agent A outputs to a specific file → agent B's input references that file → agent B builds on it → outputs to next file → loop continues
no context loss. no re-explaining. each agent gets only what it needs.
example flow:
founder-architect → outputs 01_Blueprint_Foundation.md structural-data-architect → inputs that file → outputs 02_System_Structure_and_Data.md …and so on
the orchestrator manages the sequence. agents don't need to know about each other. they just follow their protocol.
the hard lessons baked into these:
– never let the agent decide the output format. u decide.
– always tell it what to ignore, not just what to do.
– version ur protocols. u will iterate.
– line count ranges > "be concise" or "be detailed"
– if an agent's scope creeps, split it into two agents.
open sourced the whole thing. all 20+ prompt md files if anyone want to try it.