메뉴
Jeffrey Emanuel's comprehensive markdown planning methodology for software projects. The 85%+ time-on-planning approach that makes agentic coding work at scale. Includes exact prompts used.
Codex 또는 Claude로 설치 이 Prompt를 복사해 Codex, Claude 또는 다른 어시스턴트에 붙여 넣으면 Skill 페이지를 검토하고 설치를 진행할 수 있습니다.
SOC 직업 분류 기준
The philosophy and practical benefits of agent fungibility in multi-agent software development. Why homogeneous, interchangeable agents outperform specialized role-based systems at scale.
Jeffrey Emanuel's multi-agent implementation workflow using NTM, Agent Mail, Beads, and BV. The execution phase that follows planning and bead creation. Includes exact prompts used.
Named Tmux Manager - Multi-agent orchestration for Claude Code, Codex, and Gemini in tiled tmux panes. Visual dashboards, command palette, context rotation, robot mode API, work assignment, safety system. Go CLI.
MCP Agent Mail - Mail-like coordination layer for multi-agent workflows. Identities, inbox/outbox, file reservations, contact policies, threaded messaging, pre-commit guard, Human Overseer, static exports, disaster recovery. Git+SQLite backed. Python/FastMCP.
Converting markdown plans into beads (tasks with dependencies) and polishing them until they're implementation-ready. The bridge between planning and agent swarm execution. Includes exact prompts used.
Beads Viewer - Graph-aware triage engine for Beads projects. Computes PageRank, betweenness, critical path, and cycles. Use --robot-* flags for AI agents.
| name | planning-workflow |
| description | Jeffrey Emanuel's comprehensive markdown planning methodology for software projects. The 85%+ time-on-planning approach that makes agentic coding work at scale. Includes exact prompts used. |
Core Philosophy: "Planning tokens are a lot fewer and cheaper than implementation tokens."
The models are far smarter when reasoning about a detailed plan that fits within their context window. This is the key insight behind spending 80%+ of time on planning.
Before burning tokens with a big agent swarm:
┌──────────────────────────────────────────────────────────────┐
│ 1. INITIAL PLAN (GPT Pro / Opus 4.5 in web app) │
│ └─► Explain goals, intent, workflows, tech stack │
├──────────────────────────────────────────────────────────────┤
│ 2. ITERATIVE REFINEMENT (GPT Pro Extended Reasoning) │
│ └─► 4-5 rounds of revision until steady-state │
├──────────────────────────────────────────────────────────────┤
│ 3. MULTI-MODEL BLENDING (Optional but recommended) │
│ └─► Gemini3 Deep Think, Grok4 Heavy, Opus 4.5 │
│ └─► GPT Pro as final arbiter │
├──────────────────────────────────────────────────────────────┤
│ 4. CONVERT TO BEADS (Claude Code + Opus 4.5) │
│ └─► Self-contained tasks with dependency structure │
├──────────────────────────────────────────────────────────────┤
│ 5. POLISH BEADS (6+ rounds until steady-state) │
│ └─► Cross-model review, never oversimplify │
└──────────────────────────────────────────────────────────────┘
Use GPT Pro with Extended Reasoning in the web app. No other model can touch Pro on the web when dealing with input that fits its context window.
Alternative: Claude Opus 4.5 in the webapp is also good for initial plans.
You don't even need to write the initial markdown plan yourself. You can write that with GPT Pro, just explaining what it is you want to make.
Paste your entire markdown plan into GPT Pro with Extended Reasoning enabled and use this EXACT prompt:
Carefully review this entire plan for me and come up with your best revisions in terms of better architecture, new features, changed features, etc. to make it better, more robust/reliable, more performant, more compelling/useful, etc. For each proposed change, give me your detailed analysis and rationale/justification for why it would make the project better along with the git-diff style change versus the original plan shown below:
<PASTE YOUR EXISTING COMPLETE PLAN HERE>
After GPT Pro finishes (may take 20-30 minutes for complex plans), paste the output into Claude Code with this EXACT prompt:
OK, now integrate these revisions to the markdown plan in-place; use ultrathink and be meticulous. At the end, you can tell me which changes you wholeheartedly agree with, which you somewhat agree with, and which you disagree with:
```[Pasted text from GPT Pro]```
Different models have different strengths. Blending gets "best of all worlds."
I asked 3 competing LLMs to do the exact same thing and they came up with pretty different plans which you can read below. I want you to REALLY carefully analyze their plans with an open mind and be intellectually honest about what they did that's better than your plan. Then I want you to come up with the best possible revisions to your plan (you should simply update your existing document for your original plan with the revisions) that artfully and skillfully blends the "best of all worlds" to create a true, ultimate, superior hybrid version of the plan that best achieves our stated goals and will work the best in real-world practice to solve the problems we are facing and our overarching goals while ensuring the extreme success of the enterprise as best as possible; you should provide me with a complete series of git-diff style changes to your original plan to turn it into the new, enhanced, much longer and detailed plan that integrates the best of all the plans with every good idea included (you don't need to mention which ideas came from which models in the final revised enhanced plan):
[Paste competing plans here]
| Project | Plan Link |
|---|---|
| CASS Memory System | PLAN_FOR_CASS_MEMORY_SYSTEM.md |
| CASS GitHub Pages Export | PLAN_TO_CREATE_GH_PAGES_WEB_EXPORT_APP.md |
| Project Type | Link |
|---|---|
| NextJS webapp + TypeScript CLI | brenner_bot/AGENTS.md |
| Bash script project | repo_updater/AGENTS.md |
| Good Plan | Great Plan |
|---|---|
| Describes what to build | Explains WHY you're building it |
| Lists features | Details user workflows and interactions |
| Mentions tech stack | Justifies tech choices with tradeoffs |
| Has tasks | Has tasks with dependencies and rationale |
| ~500 lines | ~3,500+ lines after refinement |
Q: Shouldn't I code a skeleton first? A: You get a better result faster by creating one big comprehensive, detailed, granular plan. That's the only way to get models to understand the entire system at once. Once you start turning it into code, it gets too big to understand.
Q: What about problems I didn't anticipate? A: Finding the flaws and fixing them is the whole point of all the iterations and blending in feedback from all the frontier models. If you follow the procedure using those specific models and prompts, after enough rounds, you will have an extremely good plan that will "just work." After implementing v1, you create another plan for v2. Nothing says you can only do one plan.
Q: How do I divide tasks for agents? A: Each agent uses bv to find the next optimal bead and marks it in-progress. Distributed, robust, fungible agents.
Q: Do agents need specialization? A: No. Every agent is fungible and a generalist. They all use the same base model and read the same AGENTS.md. Simply telling one it's a "frontend agent" doesn't make it better at frontend.
Q: Which tech stack should I use? A: This is part of the "pre-planning" phase. Usually I already know based on project type:
Q: Should design decisions be in markdown or beads? A: The beads themselves can and should contain this markdown. You can have long descriptions/comments inside the beads—they don't need to be short bullet point type entries.
Keep best practices guides in your project folder and reference them in AGENTS.md:
Have Claude Code search the web and update them to latest versions.
Carefully review this entire plan for me and come up with your best revisions in terms of better architecture, new features, changed features, etc. to make it better, more robust/reliable, more performant, more compelling/useful, etc. For each proposed change, give me your detailed analysis and rationale/justification for why it would make the project better along with the git-diff style change versus the original plan shown below:
<PASTE YOUR EXISTING COMPLETE PLAN HERE>
OK, now integrate these revisions to the markdown plan in-place; use ultrathink and be meticulous. At the end, you can tell me which changes you wholeheartedly agree with, which you somewhat agree with, and which you disagree with:
```[Pasted text from GPT Pro]```
I asked 3 competing LLMs to do the exact same thing and they came up with pretty different plans which you can read below. I want you to REALLY carefully analyze their plans with an open mind and be intellectually honest about what they did that's better than your plan. Then I want you to come up with the best possible revisions to your plan (you should simply update your existing document for your original plan with the revisions) that artfully and skillfully blends the "best of all worlds" to create a true, ultimate, superior hybrid version of the plan that best achieves our stated goals and will work the best in real-world practice to solve the problems we are facing and our overarching goals while ensuring the extreme success of the enterprise as best as possible; you should provide me with a complete series of git-diff style changes to your original plan to turn it into the new, enhanced, much longer and detailed plan that integrates the best of all the plans with every good idea included (you don't need to mention which ideas came from which models in the final revised enhanced plan):
[Paste competing plans here]