LFG

Take an ask to a demoable proof of concept with one short conversation, then run unattended to a reviewed PR.

The output is a walking skeleton of tracer bullets, not a prototype. Each slice is thin, production-structured code that runs end to end, proven by one test that also drives the demo path. What a run cuts is completeness and robustness, and every cut is filed as an issue. It never cuts structure. That is the Hunt & Thomas distinction between a tracer and a prototype, and it is why the code can later be promoted or discarded by a human decision rather than by accident. Promotion needs judgment from outside the run that built it (Beck's 3X: moving from Explore to Expand is a call someone else makes).

Invocation Position

Side-route, user-invoked only. It fires when a human types /lfg <ask>; disable-model-invocation: true keeps its description out of every other session's context. Use it when a demo window is closing, such as a spike you want to show someone, and the full pipeline's human gates would cost more than the build. For a judged hackathon day, use /hackathon, which adds project selection, clock checkpoints, and the demo.

Send it as its own message, not as the first message of a fresh workspace. A slash command is recognized only at the start of a message, and a host that prepends anything to your first one — Conductor prepends a workspace preamble — displaces it. The command is then read as ordinary prose, and because this skill is hidden from the model by the flag above, the model cannot look it up: three of the first six field invocations were lost this way, and the runs that followed had no shape-lite, no marker, and no ledger. Nothing in this file can catch that, because this file is what failed to load. If a session did work that looks like an /lfg run but has none of those artifacts, this is why; retype /lfg and start over (chrislacey89/skills#383).

It stands beside /shape → /research → /write-a-prd → /prd-to-issues → /execute and reconnects to the main workflow at /pre-merge --loop. From there the PR is an ordinary stamped PR: the user settles its ledger, and /closeout merges it if the user decides to keep the code.

Use the full pipeline instead for production features, and for any work you mean to keep without a later human review.

What this skill never does. It never writes the review-currency stamp. /pre-merge is that stamp's only writer, pinned by scripts/test-review-currency-marker.sh. It never fixes a /pre-merge finding in-run, never merges, never runs /closeout or /compound, and never creates per-slice issues.

Locked vocabulary

The recap, the gap issues, and the calibration in chrislacey89/skills#372 read these values. Change one here and nowhere else.

Stops

After shape-lite ends, ask the user a question only for one of these stop classes:

• credential: an account, key, or login only the user can supply.
• destructive: an irreversible action, such as dropping data, force-pushing, or deleting something the run did not create.
• spend: anything that costs money, such as a paid tier, a purchase, or metered usage beyond a free tier.
• product-fork: two directions that would produce materially different demos, where the shape-lite summary does not settle which one.

For every other decision, take the recommended answer, keep going, and add the decision to the recap's decision log. A question outside these classes stalls a run that nobody is watching, which defeats the point of an unattended run.

A stop ends the turn, so it is an exit path (see Exit paths). Remove the marker before you ask. When the user answers, run the marker-creation block again and resume where the run stopped. Count every stop by class for the recap's tally.

One stop comes before the run and asks nothing: Before anything: the backend in Process stops both paths when backend slices or backend stamp answers sidecar, or when either refuses. It is not a stop class, because no run has started to resume and there is no tally to count it in.

Process

Before anything: the backend

This skill writes to GitHub on both paths. The feature path files the PRD-lite, the gap issues, and a roll-up comment. Both paths open the PR with the recap as its body. On a repo whose backend is the sidecar, those writes would put pack text on a host that does not allow it (references/state-backend.md § What the write lists mean), and this skill has no sidecar arm for any of them. So ask first, before Step 0 sizes the ask and before anything is written, through the bundled resolver references/sidecar.sh at its absolute installed path:

SC="<this skill's directory>/references/sidecar.sh"
slices="$(bash "$SC" backend slices)" || slices=
stamp="$(bash "$SC" backend stamp)" || stamp=
case "$slices $stamp" in
  "github github") echo "backend: github" ;;
  *" "|" "*) echo "lfg aborted: sidecar.sh backend failed; not guessing the github path" >&2; exit 1 ;;
  *sidecar*) echo "lfg stopped: this repo's backend is the sidecar (slices: $slices, stamp: $stamp), and /lfg writes only to GitHub. Use /execute, or /write-a-prd → /prd-to-issues → /execute, which route their writes through the backend." >&2; exit 1 ;;
  *) echo "lfg aborted: sidecar.sh backend answered [$slices $stamp]; not guessing" >&2; exit 1 ;;
esac

With no sidecar, backend answers github, so the tiny path needs no sidecar for this check. github on both proceeds to Step 0. sidecar on either stops the run: print the block's message and do not start shape-lite or the tiny path. Anything else is a refusal: stop and relay what backend printed on stderr. Nothing has been written yet, and no marker exists, so this stop has no exit-path cleanup.

0. Auto-size

Read the ask against the conditions in references/trivial-task-rule.md. An ask typed into /lfg is not tied to an issue, PRD, or QA bug unless the user named one.

• Every condition holds → tiny path.
• Any one fails, or you are unsure → feature path.

State the verdict and the condition that decided it in one line, then proceed without asking.

Branch. Mirror /execute Step 0. If the host provisioned the worktree (.claude/settings.json worktree.provisioning: host, or the block below prints host_owned=yes), build on the current branch. Otherwise, create lfg/<slug> from the default branch. This skill provisions no worktree of its own.

# host-signal: does a host env var describe THIS tree, not just this shell?
host_owned=no
top=$(cd "$(git rev-parse --show-toplevel)" && pwd -P)
if [ -n "${CONDUCTOR_WORKSPACE_PATH:-}" ]; then
  ws=$(cd "$CONDUCTOR_WORKSPACE_PATH" 2>/dev/null && pwd -P) || ws=
  if [ -n "$ws" ]; then
    case "$top/" in "$ws"/*) host_owned=yes ;; esac
  fi
fi
if [ -n "${CODESPACES:-}" ] || [ -n "${REMOTE_CONTAINERS:-}" ]; then host_owned=yes; fi
echo "host_owned=$host_owned"

A bare CONDUCTOR_WORKSPACE_PATH is not enough: it leaks into shells started under Conductor and can name another repository's workspace.

Sidecar (feature path only). Why this stop exists is stated in /init-pipeline § 8. Check for it now, while the user is still here, through the bundled resolver references/sidecar.sh at its absolute installed path:

SC="<this skill's directory>/references/sidecar.sh"
bash "$SC" resolve

Exit 0 proceeds. Exit 1 alone does not mean there is no sidecar: it is also the exit for "not inside a git repository" and for a sidecar found whose new alias could not be committed. Decide on the output, not the code. If stderr carries a SIDECAR MISS line with an init command: stop before shape-lite, print that command exactly as given, and say that /init-pipeline run by hand asks the questions it needs (its § 8), in one run whatever state the project's hook is in. On any other exit 1, stop and relay what the resolver printed as printed; it is not a miss, so offer no init command. Do not run init yourself, because creating a sidecar is a human act. The tiny path writes nothing to a sidecar and skips this check.

Tiny path

1. Create the skip marker, exactly as the trivial rule directs:

   mkdir -p "$CLAUDE_PROJECT_DIR/.claude" && touch "$CLAUDE_PROJECT_DIR/.claude/.tdd-skipped"

2. Make the fix.
3. Run it. Execute whatever proves the fix: the command, the page, or the existing test. A fix you only read counts as unverified.
4. Remove the skip marker, then commit:

   rm -f "$CLAUDE_PROJECT_DIR/.claude/.tdd-skipped"

5. Run the feature path's Close step from item 3, Open the PR, skipping item 7. The tiny path creates no PRD-lite issue and no tracer test, so its recap omits those lines.

Feature path

1. Shape-lite (HITL, the only human phase)

1. State 3–5 assumptions you are making about the ask.
2. Ask /shape Phase 1's five questions, one per turn, each with your recommended answer. Point at /shape for the questions and do not rephrase them.
3. Print /shape Phase 3's closing summary.

Stop there. Skip the rest of /shape: no name test, no branch walking, no stress test of decisions. Human involvement ends when the summary is printed, and the next question the user sees must belong to a stop class.

2. Research-lite (AFK)

Run /research Phase 0 only, which covers the manifest version check and the spec-anchor check. Write the result to the per-user archive at the path /research uses. Resolve every Uncertain assumption toward the choice that keeps the demo path shortest, and log it.

3. PRD-lite issue (AFK)

File one GitHub issue with five sections: Problem, Solution, Rabbit Holes, No-gos, and a Slices checklist. Slice 1 is the walking skeleton, the thinnest path that runs end to end through every layer the demo touches. The slice cap applies. File every slice past the cap as a gap issue (step 5) before building starts. Do not create per-slice issues.

Reader: /pre-merge --loop Phase 1 takes this issue's number as its PRD.

4. Scaffold (AFK)

Run /execute Step 0's pipeline hooks gate first, and let its verdict pick the path. Run the gate, do not restate it — it is the list of terms that decides this, and a second copy of that list here is the drift docs/restated-claims.md describes. Invoke /init-pipeline only now, after shape-lite has ended, and say in the invocation that it is auto-invoked, not run by hand, and that the run is non-interactive with nobody present to answer; otherwise it may take the user-present paths and ask its questions.

• hooks-absent → invoke it and declare Path B: the trigger-surface question takes its default.
• hooks-stale → invoke it and declare Path C.
• hooks-lock-present → do not invoke it. With nobody present it has nothing to do on that hook (its § 2 "No path" case).

Neither Path B nor an auto-invoked Path C runs /init-pipeline § 8, which is why Step 0 checked the sidecar first. Git guardrails stay on.

This matters more to this skill than to any other, because .claude/.lfg-active is the newest marker: a project whose hook predates it accepts every other marker and not this one, so the stand-down this step is about is exactly the one missing. An inert marker does not fail loudly — the hook goes on refusing implementation writes, and the refusal names /tdd, which the feature path does not use.

When this step's branch completes (/init-pipeline has returned, or at once on hooks-lock-present, where it was never invoked), create the run marker on every branch. This is the only marker-creation block in this skill:

: "${CLAUDE_PROJECT_DIR:=$(git rev-parse --show-toplevel)}"
mkdir -p "$CLAUDE_PROJECT_DIR/.claude"
touch "$CLAUDE_PROJECT_DIR/.claude/.lfg-active"

While the marker exists, the classification hook stands down for implementation writes. The feature path uses no /tdd, because the tracer test is the test.

5. Build loop (AFK)

For each slice, in order:

1. Write the tracer test outside-in, against the running app, for the slice's demo path. Use references/tracer-test.md for the recipe.
2. Write the code that makes it pass.
3. Run the tracer test. Passing means the runner exits 0.
4. Commit the slice.
5. Tick the slice's box in the PRD-lite's Slices checklist, with the guarded mktemp → fetch-with-exit-check → byte-count → edit → refuse-if-shorter → gh issue edit <PRD-lite> --body-file shape /pre-merge Phase 5 uses for its ledger, with gh issue view <PRD-lite> fetching through -q .body. Take only that guarded read-and-write half: not Phase 4's ## Review Currency edit, its .claude/.review-stamped touch, or its marker rm -f, which would lock the branch and delete the run marker. Change that slice's - [ ] to - [x] and nothing else. Tick it here, after the commit, not in a sweep at Close: an error-path exit then still leaves a checklist that says which slices shipped. A slice stubbed at the attempt cap stays unticked, because its gap issue is the record that it did not ship.

Attempt cap. A failed run in step 3 is one attempt. When a slice reaches the attempt cap without a passing run, stop working it. Reduce it to a stub that keeps the skeleton wired, commit the stub, file a gap issue, and move to the next slice. This is /execute's plateau stop rule at a smaller scale: attempts that do not advance end the slice rather than earning another try.

Filing a gap issue. Use this for a slice past the slice cap, a slice stubbed at the attempt cap, and the ledger roll-up in Close step 6. A slice's body follows /execute's continuation-comment shape: what was done, what remains, the gotchas, and the exact error output when an error caused it. The roll-up's body is the checklist in Rolling up the ledger. Link the PRD-lite issue. The label reader is the user deciding what to promote. Create the label if it is missing (look up gh label create --help at runtime).

gh issue create --label "<gap label>" --title "<what was cut>" --body-file "$GAP_BODY_FILE"

6. Prove (AFK)

Run the whole tracer suite in one invocation. The config in references/tracer-test.md captures a screenshot for every test, so each passing test leaves one under test-results/. For a non-web app, the proof is the transcript file each tracer writes. Record every artifact path for the recap.

Optional walk. If command -v agent-browser resolves, walk the demo path once and save a final screenshot. Load its current command reference with agent-browser skills get core at runtime instead of writing commands from memory. If it does not resolve, skip the walk, because the tracer screenshots already prove the path.

7. Close (AFK)

1. Remove the marker (see Exit paths, success path).
2. Commit anything outstanding.
3. Open the PR with the recap as its body (see Recap). The banner is the body's first line, and the body includes Closes #<PRD-lite> on the feature path.
4. Invoke /pre-merge --loop, passing the PRD-lite issue number, or "none" on the tiny path. Loop-mode updates the existing PR, reviews it, writes its ledger, and stamps it.
5. Read the PR body back. If the banner is no longer the first line, put it back with the guarded mktemp → fetch-with-exit-check → byte-count → edit → refuse-if-shorter → gh pr edit --body-file shape /pre-merge Phase 5 uses for its ledger.
6. Roll up the ledger (see Rolling up the ledger). Sort the rows in state open into checklist items and no-change rows, and file the roll-up issue whose body is the checklist; note its number the moment it is filed. File none when no row is an item. Then, in one guarded write of the PR body, set every open row's state to filed, each with the number Rolling up the ledger assigns it. The same write fills in the recap's gaps: and ledger: lines. That is the ledger transition in Locked vocabulary, and the only ledger write this skill makes. Rows marked fixed, accepted, or dropped are decisions for the user. Then check it finished: read the PR body back and count the rows of its ## Review Disposition Ledger table whose State cell is open (/pre-merge's ledger defines the columns). The word open anywhere else in the body, such as the ledger's fixed prose line or an Evidence cell, is not a row. A non-zero count while the PR is open means the write did not land. Resume at the write only: the roll-up is already filed, so reuse its number (find it by its gap label and its link to the PRD-lite if you no longer hold it) and file nothing again. Retry the write until the roll-up write cap is spent. When the cap is spent with a row still open, take the Error path (see Exit paths), which says what happens from here.
7. Post one roll-up comment on the PRD-lite issue that lists every gap issue, the stop tally, and an Observations list with one line per no-change row: its title and any file:line ref.
8. Print the handoff (see Handoff). Render no next-step menu: nobody is present to answer it, so the printed line is the whole handoff.

Exit paths

The marker must not outlive the run, and removing it must come before /pre-merge --loop writes the stamp. A stamped branch never carries a classification marker, and the post-review edit lock depends on that. Every way out of the feature path runs this block:

rm -f "$CLAUDE_PROJECT_DIR/.claude/.lfg-active"

• Success path: Close step 1, before the PR is opened and before /pre-merge --loop.
• Stop path: before asking the user any stop-class question. Recreate the marker with step 4's block when the run resumes.
• Error path: when something outside the attempt cap ends the run, such as a failed tool, a lost dev server, or an /init-pipeline that does not return. Remove the marker first. Then leave a comment in /execute's continuation shape, with the exact error: on the PRD-lite issue on the feature path, and on the PR on the tiny path, which has no PRD-lite and whose PR is its only durable surface. If slices were committed and the failure came before Close step 6, run Close from step 2 so the partial work still reaches /pre-merge --loop. An entry from Close step 6 (the roll-up write cap spent with a row still open) does not re-enter Close, because the PR is already open and stamped and a second pass would file a second roll-up. The comment names the roll-up's number and the rows left unfiled, and the run ends there: it does not retry, skips steps 7 and 8, and prints the Open-rows handoff in Handoff, because the write that would have filled in the PR body's ledger: line is the one that failed.

Rolling up the ledger

Close step 6 rolls up the ledger's open rows. Filing one issue per row produced 8 to 18 issues per PR, and about a third of them asked for no change (chrislacey89/skills#688). This section decides which rows become items, when two rows are one item, and what an item looks like.

A run files at most one roll-up issue. Every row that became one of its items records its number when the row moves to filed; a no-change row records the PRD-lite's number, where step 7 lists it (on the tiny path, the PR's own number, where the recap lists it).

No-change rows. A row is a no-change row when it asks for no edit and its text has one of three shapes:

1. A size or raw-diff observation: a count of lines, files, or commits, or a description of the diff's shape.
2. A note with no action: the row itself says nothing is to be done ("note:", "no action", "for the record").
3. A "decide whether" with no concrete change: the row poses a question and names no edit at any file:line.

A "decide whether" that does name an edit, saying what to change and where, is an item. When unsure, make it an item: an item the user deletes costs less than a change nobody sees again. No-change rows go to the Observations list (Close step 7, or the recap on the tiny path), never into the checklist.

One item per defect. Two rows become one item when their file:line refs overlap, meaning the same file and line ranges that intersect. Similar wording alone never merges two rows, and a row with no file:line ref merges with nothing. The ledger keeps both rows, because they record that two reviewers reached the same verdict (chrislacey89/skills#379). The merged item names both rows and carries each row's proposed change, so a wrong merge costs a longer item, not a lost finding.

Item shape. One line per item, the title first:

- [ ] <title> — `<path>:<line>`, `<path>:<line>` — <proposed change> (ledger: pass <p>, <dimension>; pass <p>, <dimension>)

The title is the row's Finding cell. The proposed change is the one the row states, or one clause naming the fix when the row states only the defect.

Recap

The PR body is the recap, and its reader is the user deciding whether to demo, promote, or discard. It carries, in this order:

1. The banner first line, then a cut: line naming what the run left out and a gaps: line linking each slice's gap issue and the ledger roll-up.
2. Decisions taken without you, one line each, including every assumption resolved in research-lite.
3. Stop tally, with each stop by class. A stop outside the stop classes is a defect in the run, so list it anyway.
4. Ledger tally, a ledger: line with the rows by state and where the filed ones went, e.g. ledger: 14 rows, 0 open, 14 filed (9 rows as 7 items in the roll-up, 5 observations). The ledger does not exist when the PR opens, so Close step 6 writes this line, and only when its write lands. When the roll-up write cap is spent, the PR body has no ledger: line, and the Error path's continuation comment and the Open-rows handoff are the record. On the tiny path it is followed by the Observations list that step 7 would otherwise post.
5. Proof, with each screenshot or transcript path and the command that produced it.
6. On the feature path, Closes #<PRD-lite>.

The PR body becomes the squash commit's message, and GitHub reads closing keywords in commit messages too, quoted or negated (GitHub docs). In every section, refer to an issue that must stay open without one, e.g. "leaves #N open".

Common Rationalizations

Red Flags

• A question to the user after shape-lite that names no stop class.
• A tracer test that never ran, or a slice committed without a passing run or a gap issue.
• .claude/.lfg-active present when /pre-merge --loop starts, or present after the run ends.
• A ledger row this skill set to anything other than filed.
• A normal handoff printed while the PR is open and its ledger still has a row in state open. The Open-rows handoff in Handoff, which names those rows, is the one handoff allowed then.
• A roll-up that breaks the cap Rolling up the ledger states or a no-change row filed as an item.
• A shipped slice whose PRD-lite box is unticked, or a stubbed slice whose box is ticked.
• A PR body whose first line is not the banner.
• Per-slice issues, a /tdd invocation on the feature path, or a /closeout.

Handoff

• Expected input: an ask typed as /lfg <ask>, plus a user present for shape-lite on the feature path. GitHub backend only for now: on a repo where backend slices or backend stamp answers sidecar, the skill stops before writing anything and sends the user to /execute.
• Produces: a stamped PR whose body is the recap (banner, decisions, gap issues, stop tally, ledger tally, proof paths); a PRD-lite issue on the feature path, its slice boxes ticked for the slices that shipped; a gap issue per cut or stubbed slice and the ledger roll-up issue Rolling up the ledger describes, all carrying the gap label; open ledger rows moved to filed.
• May invoke: /init-pipeline (Path B, or Path C on a stale hook), /pre-merge --loop.
• Returns control to: the user, who demos the branch and then decides whether to promote or discard it.
• Comes next by default: the user. To keep the code, settle the ledger and run /closeout. To discard it, close the PR.

Print, substituting the real values:

**Next session:** /closeout
**Input:** PR #<n> on branch <branch-name> — an LFG proof of concept; read its banner and ledger before merging

Open-rows handoff. When Close step 6 ended the run on the Error path with a row still open, print this instead. It states the unfinished state plainly and points at the record, so it cannot be read as a finished run:

**Next session:** settle the open ledger rows, then /closeout
**Input:** PR #<n> on branch <branch-name> — an LFG proof of concept; the ledger roll-up did not finish. <k> rows are still `open` in its Review Disposition Ledger and the PR body has no `ledger:` line. Roll-up issue: #<m>, or none filed. The continuation comment on the PRD-lite has the exact error