A guide for people who are not developersForge

You know your work. You have an idea for a tool that would make it easier. What you do not have is years of software habits. Forge supplies the habits, asks you the right questions, and refuses to let the project become a mess.

The only command you have to remember
/forge

Type it whenever you sit down. It works out where the project stands and does the next thing.

AudienceTechnical, not a developer
Runs inClaude Code
Reading timeAbout 20 minutes
Editionv1.0.0  /  for Claude 5

New in v1.0.0  /  tuned for Claude 5

Forge has been rewritten for the current generation of Claude models. The instructions behind it are about a quarter shorter, because these models need far less hand-holding than the ones Forge was originally written for.

Nothing you do changes. Same three phases, same approval gate, same files in your project. If you are on an older Claude 4 era model, there is a separate edition for you: see which edition below.

01

What this is, and what it saves you from

Software projects fail in boring ways. You describe what you want too vaguely and get the wrong thing. You lose two days of work because nothing was saved properly. You come back after a week and cannot remember what you were doing. You ship something that quietly broke last Tuesday and nobody noticed.

Forge is a set of instructions that runs inside Claude Code. It does not write your software for you so much as it insists on doing it in an order that works, and it stops at the points where a human has to make a real decision.

It does this for you

The professional habits

  • Asks until it actually understands your idea
  • Sets up your computer with the right tools
  • Writes automated checks that catch mistakes
  • Saves work constantly so nothing is lost
  • Keeps documentation truthful
  • Packages finished versions you can point at
You do this

The judgment calls

  • Answer questions about what you want
  • Read the plan and approve it
  • Decide who can see the project
  • Approve anything that needs admin rights
  • Say when a version is ready to release

You do not need to know how to code

You do need to know your own problem well enough to answer questions about it. If you can explain to a colleague what is annoying you and what "fixed" would look like, that is enough to start.

02

The mental model

Three phases, in order, with a hard stop between each. You cannot skip ahead, and neither can Claude. Think of it the way a building goes up: drawings get approved before anyone pours concrete.

PHASE 1 DESCRIBE IT Claude interviews you until it understands. OUT: a written spec GATE You approve the spec PHASE 2 PREPARE Installs tools, sets up safety nets, proves both. OUT: a working bench GATE Everything proven working PHASE 3 BUILD IT One small piece at a time, each one tested. OUT: the finished tool SHIP
Fig. 1  /  The three phases. Dashed red lines are gates: Claude stops and waits for you.

How /forge knows where you are

You never tell it which phase you are in. It looks at your project and works it out. Expand a rung to see what happens in that situation.

03

Which edition to install

Forge comes in two editions. They do the same job and produce the same project. The only difference is which generation of Claude model the instructions inside are written for, and that matters more than it sounds like it should.

Newer models follow instructions closely and check their own work without being told to. Older ones needed to be reminded, repeatedly and in detail. Give a newer model the older style and it over-checks everything and wastes effort. So there is one edition per generation rather than one that tries to suit both.

If you useInstallType this
A current Claude model
Claude 5 era. This is almost certainly you.
forge-workflow
v1.0.0
/forge
An older Claude model
Claude 4 era
forge4-workflow
v0.1.0, frozen
/forge4

If you are not sure which you are on, install the first one. It is the maintained edition, and it is what the rest of this guide describes.

Install one at a time

Both editions run the same background scripts, so having both switched on at once makes those scripts fire twice. Harmless but noisy. Install the one you need, and if you ever want to try the other, switch the first one off first.

The older edition has its own copy of this guide at daileng.github.io/forge4-workflow.

04

Setting it up, once

Two commands. Claude Code fetches Forge from a public catalog and installs it for you. These install the Claude 5 edition, which is the one you want unless you read section 03 and decided otherwise.

# point Claude Code at the catalog, then install the plugin
claude plugin marketplace add DailenG/dailens-claude-toolbelt
claude plugin install forge-workflow@dailen

Confirm when it asks, then run /reload-plugins or restart Claude Code. Type / and you should see forge in the list along with three others. Those three are manual overrides you will probably never need.

When a new version ships later, claude plugin marketplace update dailen pulls it down.

One prerequisite worth checking

Forge uses small background scripts that need Node.js installed. If it is missing, everything still works except the automatic memory between sessions, which is a real loss. Forge checks this itself and tells you, so you do not have to remember.

The manual way, if you would rather

Prefer to drop the folder into place by hand? Download the zip from the releases page, close Claude Code, then extract it so the folder lands here:

C:\Users\<you>\.claude\skills\forge-workflow\

On Windows, that .claude folder is hidden. Paste the path into the Explorer address bar rather than trying to click your way to it. Check it worked:

# should report no problems
claude plugin validate $env:USERPROFILE\.claude\skills\forge-workflow --strict

# should list forge-workflow@skills-dir
claude plugin list

Restart Claude Code and you land in the same place as the two-command install above.

05

Phase one: describing the idea

Make an empty folder, open Claude Code inside it, and type /forge. Nothing else.

It will start asking questions in small batches, three to seven at a time, with lettered options where there is a sensible shortlist. Most rounds you can answer with a few letters and a phrase.

You
/forge
Claude

Round 1. Before anything else I need to know what problem this solves.

1. In a sentence or two, what should this do, and what is unacceptable about how things work today?

2. Who uses it? (a) just you, (b) your team, (c) customers. No recommendation, this is yours to answer.

3. Where is it used from? (a) a command line, (b) a desktop window, (c) a web page, (d) a phone.

You
1. Our file shares collect very long folder paths and backups fail with useless errors. I want to find them before the backup does.
2. a
3. a
Claude

Confidence: 20 out of 100. Held down by testing, which we have not discussed.

Round 2. Now the part that decides everything else...

The confidence score

After each round it scores how well it understands ten areas, and reports the lowest one, not the average. That is deliberate. Averaging lets a single unanswered question hide behind nine confident ones, and that question is usually the one that wrecks the project later.

It keeps going until the lowest score reaches 95. In practice that is six to eight rounds and maybe twenty minutes.

Expect it to push back

It will press hardest on two things people skip. Testing: how you will know the thing actually works. Non-goals: what this deliberately will not do. Vague answers here produce a vague spec, so it does not let them pass.

Choosing the technology

Once it understands the problem, it presents two or three options for what to build it in, with honest downsides for each, and recommends one. You can accept or override. If you override, your reason gets written down alongside the original recommendation, so in a year you can see why.

06

The approval gate

Phase 1 ends with a written specification and a full stop. Claude will not approve its own spec. This is the most valuable twenty minutes in the project, so actually read it.

Check this

Can each requirement be proved?

Every numbered requirement should describe something you could verify. "Fast" is not a requirement. "Returns results in under two minutes for 300,000 files" is.

Check this too

Is the non-goals list honest?

This is where scope creep gets prevented. If something you secretly want is listed as a non-goal, say so now. Later is much more expensive.

When you approve, the spec becomes a living document. It can still change, but only by adding a dated amendment explaining what changed and why, never by quietly rewriting history.

What to say

"Approved" is enough. Or list what you want changed first. Then type /forge again and it moves itself to Phase 2.

07

Phase two: preparing the bench

This phase touches your computer, so it is the one most likely to need you. It assumes nothing is installed and checks everything, but only installs what is genuinely missing.

Step A

It inventories your machine

Prints one table: what it needs, what you have, what is missing. Then installs the gaps.

Step B

It may ask for administrator rights

Claude cannot grant itself admin. If something needs it, you get instructions for opening an elevated window, one block of commands to paste, and a command to run afterwards to prove it worked. It waits, then checks your result rather than taking your word for it.

Step C

It proves the safety nets actually work

This is the part people skip and it is the part that matters. It deliberately writes a broken test to confirm the test system reports failures. A test runner that finds nothing usually says "success", and that one silent lie would make every future green tick meaningless.

Step D

It asks one question you must answer

Should the project be public or private? It will never guess this. Private means only you can see it. If you are unsure, choose private; you can open it up later, but you cannot un-publish something.

About that "pre-push check"

Forge installs a guard that runs every time work is saved to the server: it builds the project, runs the tests, and scans for accidentally included passwords. If any fail, the save is refused. It will block you occasionally. That is the point, and Claude is instructed never to force its way past it.

Protecting the main line of work

The main copy of your project must not be deletable, and must not accept a save that throws away history. Forge sets that up in whichever of two ways your hosting account actually allows.

Best case, the host enforces it. The rule lives on the server, so it applies to everything and everyone, including changes made through the website.

Otherwise, your machine enforces it. Some hosting plans reserve that server setting for paid accounts. GitHub free personal accounts, for example, answer "Upgrade to GitHub Pro or make this repository public to enable this feature" on a private project. Forge does not buy anything and never makes a private project public to get around it. It installs a local guard instead, which refuses a history-destroying save from this computer, and tells you once what that does not cover: a copy of the project on another machine that was never set up, a change made through the website, a guard someone deleted, or somebody who has your password. Then it carries on.

Either way, Forge proves the guard works before trusting it, using throwaway practice copies of a project rather than your real one, and writes down which of the two is in force.

08

Phase three: building in slices

Work happens in slices. A slice is one complete piece of usable behaviour, not one technical layer. "Scan a folder and print what it found" is a slice. "The database code" is not, because on its own it does nothing you can look at.

Hardest slice goes first. That feels backwards, and it is correct: if something is going to turn out impossible, you want to find out on day one, not in week three.

SAFE COPY OF THE PROJECT 01 Take a copy to work in 02 Write the test and watch it fail 03 Build until the test passes 04 Write the docs for this piece 05 Fold it back into the project REPEAT FOR THE NEXT SLICE
Fig. 2  /  One slice. Step 02 looks strange and is the most important one.

Why write the test before the thing works

Because a test that has never failed has not been shown to test anything. Plenty of tests pass because they check nothing at all, or check the wrong thing entirely, and you cannot tell the difference by reading them. Watching it fail first, then pass, proves it is connected to reality.

The rule Claude is forbidden to break

It may never make a failing test pass by weakening the test. No deleting it, no skipping it, no loosening what it checks. If a test is genuinely wrong it has to say so and ask you. This is written down explicitly because it is exactly the shortcut anything under pressure reaches for.

After each slice you get a short report: what works now, what does not yet, what is next. By default it carries straight on to the next slice. If you would rather approve each one, say so and it will wait.

09

When it stops you

Forge blocks things on purpose. A block is not a malfunction, it is the system doing the one job you cannot do by staring at the screen. Here is how to read the common ones.

What you seeWhat it means and what to do
A secret was found A password or key is about to be saved into the project history, where it would live forever. Remove it from the file and, if it was ever real, change it. Never bypass this one.
Tests failed, push refused Something that worked is now broken. Let Claude fix it. Do not ask it to skip the check.
Cannot release, requirement not covered One of your requirements has no test proving it works. Either it is not actually finished, or it needs a test. Claude will tell you which.
Typography violation A curly quote or long dash got into a file. Harmless in prose, breaks things in code. Claude fixes it itself.
Notes disagree with the project Its record of where things stand does not match reality. It stops rather than guessing. Read what it found and tell it which version is right.
Screenshots missing Documentation needs a picture Claude cannot take, usually of a window on your screen. It tells you exactly which one and what should be visible in it.

The one instruction to avoid

Never tell it to skip, bypass, or force past a check. The checks are the whole reason the project stays trustworthy while someone who does not write software is driving it. If a check is genuinely wrong, ask Claude to explain it, then decide.

10

Walking away and coming back

Real work gets interrupted. A meeting overruns, the day ends, a fortnight passes. This is the thing Forge is best at, and it needs nothing from you.

WORKING Halfway through a slice INTERRUPTED You close the laptop. Nothing is announced. WRITTEN DOWN BEFORE THIS exact file, line, and next step TWO WEEKS LATER New window. You type please continue RESUMED Checks notes against reality NOTHING IS LOST, AND NOTHING IS ASSUMED The notes are only trusted after they are checked against the real state of the files.
Fig. 3  /  Interruption and recovery. The check on the right is the part that matters.

Claude keeps a file called CONTINUE.md that always describes exactly where things stand and what the very next action is. It updates it before starting anything risky, not afterwards, so an interruption cannot catch it out.

When you return, that file is loaded automatically before you say a word. Then, crucially, it checks the notes against the actual project. If the notes claim two tests are failing but three are, it says so and asks you rather than carrying on from a false picture.

All you ever have to type

please continue or /forge. Either works. You never have to remember what you were doing.

11

Shipping it

A release is a numbered, frozen snapshot you can point people at. Forge cuts the first one as soon as anything works end to end, then again after each meaningful addition, rather than saving them all up for a big finish.

VersionWhat it signals
v0.1.0First thing that genuinely works, even if small
v0.2.0A meaningful new capability
v0.2.1A fix, nothing new
v1.0.0Every requirement done, and every one proved by a passing test

Before any release, Claude switches out of autopilot and asks. It also refuses to cut version 1.0 until every single requirement in your spec has a test proving it works. Not "the code exists", but "here is the check that demonstrates it".

Each release comes with a plain-language paragraph saying what this version proves the tool can now do. That paragraph is what you will actually read in six months when you are trying to remember where you got to.

12

The files that appear in your project

Forge creates these. You never have to edit them, but knowing what they are helps.

FileWhat it is
CONTINUE.mdWhere things stand right now. The one that makes "please continue" work.
TODO.mdWhat is planned, what is being done, what is finished.
docs/SRS.mdThe specification you approved. The source of truth for what is being built.
docs/DECISIONS.mdEvery choice made and why. Read this when you wonder "why on earth did we do it that way".
docs/ENVIRONMENT.mdWhat is installed on your machine and what versions. How you would set this up again.
docs/traceability.mdA grid matching every requirement to the test that proves it.
CHANGELOG.mdWhat changed in each release, written automatically.
README.mdHow to install and use the thing you built. Written for someone who has never seen it.
13

Plain-English words

The vocabulary you will meet, without the jargon. Terms are underlined throughout the page, so you can check one without leaving your place.

WordWhat it actually means
RepositoryYour project folder plus its full history. Every version of every file is kept, so nothing is ever truly lost.
CommitA saved checkpoint with a note explaining what changed. Like a save point in a game.
BranchA safe copy to experiment in. If it goes badly you throw the copy away and the real project was never touched.
MergeFolding a finished branch back into the real project.
PushSending your saved work up to the server so it exists somewhere other than your laptop.
GitHubThe server where the project lives. Also your offsite backup.
TestA small program that checks your program. It either passes or fails, no interpretation needed.
Test suiteAll the tests, run together. "Green" means everything passed.
CIA robot on the server that rebuilds the project and runs every test after each change, on a clean machine, in case something only worked on yours.
HookAn automatic check that fires at a set moment, like just before saving to the server.
CoverageHow much of your code the tests actually run. Useful for spotting untested areas, not a measure of quality.
SliceOne complete piece of working behaviour, built and tested end to end.
Release / tagA numbered, frozen snapshot. Tags never move once created.
Spec / SRSThe written description of what is being built, agreed before building starts.
RequirementOne numbered, provable statement of something the tool must do.
14

Quick reference

Everything you type

Commands

/forgeStart, or carry on. The only one you need.
please continueSame thing, in plain words.
/forge-specForce the describing phase.
/forge-envForce the setup phase.
/forge-codeForce the building phase.
Useful things to say

Phrases

"Approved"Passes a gate.
"Explain that"Any term or decision, in more detail.
"Wait for me each slice"Switches off autopilot.
"Where are we?"Status without doing any work.
"Why did we decide that?"It looks it up in the decisions log.

Never say these

"Skip the tests." "Force the push." "Bypass the check." "Just make it pass." Each one removes a safety net that exists precisely because nobody is reviewing the code but the machine that wrote it.

If you only remember four things

  • Type /forge. It figures out the rest.
  • Read the spec before approving it. Twenty minutes there saves days later.
  • A block is the system working. Never ask it to bypass one.
  • You can leave at any moment. Come back and say "please continue".