project-forge

A Claude skill that turns a raw project idea into a vetted, scoped, resume-ready build plan.

Type /forge a tool that flags transactions a fintech should chase before the user churns. Answer the few questions Claude can't infer. Get a set of files you drop into a fresh repo and build from in Claude Code, with the resume framing already written and the update discipline already wired in.

Why this exists

Most project ideas die one of two deaths. Either they were thin to begin with and a long build proves it three weeks too late, or they were fine but got inflated until they never shipped. Both are expensive when your time is the budget.

The fix isn't more planning. It's an honest gate before the planning starts, then a plan cut to the smallest thing that still proves a point.

So forge does two things most planning tools refuse to do. It will tell you an idea is too thin and propose a better one instead of dressing up the dead one. And it writes your resume bullets before any code exists, because if you can't state the bullet now, the project is missing the thing that would make it worth listing. Better to find that out before the build than after.

The trade-off: forge plans, it does not implement. It hands you working-memory files and gets out of the way. The build is a separate Claude Code session.

Install

Requires: A Claude plan with skills support (Pro, Max, Team, or Enterprise).

1. Download project-forge.skill.
2. In Claude, go to Settings -> Capabilities -> Skills -> Upload skill.
3. Select the .skill file. Done.

If you'd rather read before you install, the unpacked skill lives in skill/.

Use

/forge a gold fair-value tool that narrates why the price moved
/forge a momentum rotation backtester across India-accessible assets
/scope a support triage agent that decides escalate vs answer-from-docs
/forge [idea] targeting a data analyst role in Dubai

Name a target role in the invocation and the resume bullets aim at it. If you don't, forge asks once.

The skill runs interactive but it is not a form. It stops only where the plan genuinely forks, proposes with its reasoning everywhere else, and lets you redirect. Treat it like an architect conversation.

The six phases

Phase	Job
1. Intake	Read the idea plus what's already known about you. Ask only what can't be inferred, in one short burst.
2. Vet honestly	Score the idea against what a real portfolio piece needs. Three verdicts: strong (continue), weak but fixable (stop, name what's thin, offer the smallest fix), kill (stop, say why, propose a better idea for the same gap).
3. Signal and scope	Name the distinct signal this adds to your resume, flag it if it duplicates one you already have, then cut to the MVP with an explicit "not building" list.
4. Stack and modules	Propose the stack with the tradeoff behind each choice, decompose into modules slice-first, write a spec per module with an acceptance test.
5. Resume bullets	Draft the bullets now, with metric placeholders you fill once built. Aimed at the role from Phase 1.
6. Emit and hand off	Write the files pre-filled, save them, tell you exactly how to move them into a repo and start the build.

What you get

Five files, written pre-filled, ready to drop into a new repo:

• PLAN.md vetted scope, ordered module specs, the not-building list, the resume bullets.
• CONTEXT.md the facts and risks already known: schema, data shape, key decisions and why.
• PROGRESS.md an empty log with the entry template and the reminder to log and commit after each slice.
• CLAUDE.md project conventions plus every rule the build agent should execute. This is the single authoritative home for agent rules, because Claude Code reliably acts on CLAUDE.md and treats the rest as data.
• README.md the hire-me skeleton with the resume framing baked in and placeholders for metrics.

These aren't documentation. They're working memory the build reads and updates, so the discipline is wired in from day one instead of bolted on at session four when you're tired.

What it looks like under the hood

• skill/SKILL.md the entry point Claude reads on every invocation: the trigger, the six-phase flow, the honesty rule.
• skill/references/ the four reference files the phases pull in:
  • vetting.md the rubric, thresholds, and signal-gap check for Phase 2.
  • scope-and-modules.md cutting scope (Phase 3) and slicing modules (Phase 4).
  • resume-framing.md the bullet patterns and ATS rules for Phase 5.
  • build-files.md the exact template and update rule for each of the five emitted files.

If you want to fork and modify, start with SKILL.md and follow the references it points to.

Design choices worth knowing

A few opinions baked in, in case you want to argue with them:

• The vet gate can kill your idea. A polished six-phase plan for a dead idea has failed you worse than an honest "this one is too thin, build X instead." The gate is the reason the skill is worth trusting.
• The plan must be specific to your idea. If the modules, risks, and bullets would read the same for any project, the inputs went unused. A generic plan is a failed plan.
• Resume bullets come before code. If you can't write the bullet now, the project is missing its point. Find that out before the build, not after.
• Forge plans, it does not implement. The build is a separate Claude Code session in a fresh repo. Forge emits the files and hands off, on purpose.
• Direct over kind. It won't invent merit to be nice. If the idea is thin it says so and means it.

Contributing

PRs welcome. Read CONTRIBUTING.md first. The most useful issue you can file: a run where forge planned an idea it should have killed, or killed one it should have planned. Specific failures beat general feedback.

License

CC BY 4.0. Use it, fork it, build on it, just credit this repo.

Credits

Built as a Claude skill using Anthropic's skills system. The build-planning leg of a three-skill set: /aha for visual insight (interactive-educator), /drill for retention, /forge for the plan.