LRIL SDLC Archon Workflows

An Archon workflow pack that runs Matt Pocock's skills (the mattpocock/skills engineering flow) as governed, resumable, gated workflows.

Matt's skills fix the four failure modes of agentic coding: misalignment (the agent didn't do what you wanted), verbosity (no shared language), code that doesn't work (no feedback loops), and a ball of mud (no care for design). This pack keeps his methodology intact and adds what a workflow engine is good at. Every step that can be checked by code is checked by code. Every public write is performed by a script and read back. Every interview happens at an interactive gate, so you answer it on your own time, and a run can stop and resume.

archon plugin install seanrobertwright/lril-sdlc-archon
archon workflow run seanrobertwright/lril-sdlc:setup --no-worktree
archon workflow run seanrobertwright/lril-sdlc:idea-to-tickets --branch feat/saved-cards "Let customers save a card at checkout"

The flow

The pack follows the flow map in Matt's /ask-matt: one main flow from idea to ship, on-ramps that merge onto it, and upkeep that runs beside it.

flowchart LR
  setup([setup]) --> idea
  subgraph main [Main flow]
    idea[idea-to-tickets<br/>grill-with-docs, to-spec, to-tickets] --> spec[implement-spec<br/>tdd per ticket, code-review, pr]
    idea --> one[implement<br/>one ticket]
    spec --> retro[retro]
    one --> retro
  end
  triage[triage<br/>raw issues] -- ready-for-agent --> one
  diagnose[diagnose<br/>hard bugs] --> retro
  diagnose -. no correct seam .-> arch
  fog[wayfinder-chart, wayfinder-step<br/>huge foggy efforts] -- map clear --> idea
  arch[architecture<br/>deepening survey] -- pick a candidate --> idea

Workflow	Matt's skills	Mode	What it leaves behind
setup	/setup-matt-pocock-skills	AFK, no AI	docs/agents/*.md, an ## Agent skills block, GitHub labels
idea-to-tickets	/grill-with-docs (grilling, domain-modeling), /to-spec, /to-tickets, prototype, research, codebase-design	Interactive	A spec and tracer-bullet tickets on your tracker; GLOSSARY.md and ADRs committed
implement	/implement (tdd, codebase-design, code-review, pr)	AFK	One ticket built test-first, gated, reviewed on two axes, verified once, committed (optional PR)
implement-spec	/implement-spec (tdd, codebase-design, code-review, pr)	AFK	A whole spec on one integration branch, every ticket gated, one review, verified once, one PR
code-review	code-review	AFK, read-only	code-review.md: Standards and Spec, side by side
triage	/triage (grilling, domain-modeling)	Interactive	Labels, an agent brief or triage notes, .out-of-scope/ records; glossary and ADR edits committed
diagnose	diagnosing-bugs (tdd, codebase-design)	AFK	A proven red→green feedback loop, a regression test, the root cause in the commit
architecture	/improve-codebase-architecture (codebase-design, domain-modeling)	AFK, read-only	A visual HTML report of deepening opportunities
retro	/retro ()

How the skills are used

Matt splits his skills on one axis. User-invoked skills (/grill-with-docs, /to-spec, /implement, …) orchestrate. Model-invoked skills (grilling, tdd, code-review, codebase-design, …) hold the reusable discipline. In this pack, each workflow is the orchestrator: its DAG encodes the user-invoked skill's process, step by step, with its gates. Each AI node loads the model-invoked skills it needs from the mattpocock-skills Claude plugin, through Archon's per-node skills: selection. A node never sees a skill it doesn't use.

Matt's context-hygiene rules carry over:

• idea-to-tickets runs grilling, spec and tickets in one unbroken session, so the spec and tickets build on the interview itself rather than a summary of it. The verbatim transcript is also kept on disk.
• implement-spec gives every ticket a fresh context: the ticket is self-contained, so the last one's context is disposable.
• Reviewers always start fresh, receiving only the diff, and the two review axes run in parallel so neither pollutes the other.
• diagnose resumes the feedback-loop session for the fix, because the fix needs that context verbatim.

The gates

Matt's skills say what "done" means. The pack checks it with code wherever it can:

Gate	Where	What a script proves
Tracker configured	every tracker-aware workflow	docs/agents/issue-tracker.md exists and names GitHub or local markdown
Plugin version	setup	mattpocock-skills is installed, enabled, and at v1.3 or later
Shape is publishable	idea-to-tickets	the spec has every /to-spec section; tickets have acceptance criteria, real blockers, and no cycles. The interview loop can't end until this passes.
Green	implement, implement-spec (per ticket)	the implementer declared green and named its type-check, lint and test commands; the work is committed; nothing is left dirty. This gate runs no checks for a green implementer: it records the commands for Verified. An implementer that met every acceptance criterion but did not report green (a check that failed only in its own sandbox, or was still running when it reported) has its declared commands run here instead, and passes only if every one of them does.
Verified	implement, implement-spec (once, on the final tree)	the recorded check commands are re-run here, once, after the review fixes and the merge with the base, and pass. The review fixer and the merge resolver run only the type-check and the tests covering what they touched; this re-run decides, not their own report. A command that fails is run once more. One that passes then counts as passed but is marked flaky in the check record, the outcome and the PR body. Files a check command rewrites (a build that regenerates committed output) are stashed and named in the record and the PR body, not a failure. A gate that fails on its checks ends with the archon workflow resume command that reruns it.
Up to date with the base	implement, implement-spec (before the PR)	the branch merges the base branch (origin/<base>, fetched just now) before the PR is written, so the PR opens against the base it will land on. A base that origin doesn't have falls back to origin's default branch, and the PR targets that. A conflicted merge goes to one fresh resolver, which commits the merge or aborts it. Verified runs after either. The PR body's diff is taken against that base. It merges and never rebases, because the branch may already be pushed.
Red-capable loop	diagnose

The pack never hardcodes a toolchain. Implementers discover the project's own type-check, lint and test commands and report them, and the Verified gate re-runs exactly those.

Prerequisites

• Archon v0.11.1 or later, signed in to Claude (archon doctor).
• Claude Code with the mattpocock-skills plugin at v1.3 or later, installed from Matt's own marketplace. The claude-plugins-official listing is older than v1.3, and the pack names the plugin by its id, mattpocock-skills@mattpocock:

  claude plugin marketplace add mattpocock/skills
  claude plugin install mattpocock-skills@mattpocock   # or: claude plugin update mattpocock-skills@mattpocock
  

• git and bun on PATH. The deterministic nodes are TypeScript on Bun, with no npm dependencies.
• For the GitHub tracker: gh, authenticated, in a clone with a GitHub origin.

Install

archon plugin install seanrobertwright/lril-sdlc-archon          # default branch
archon plugin install seanrobertwright/[email protected]   # a tagged version

Entrypoints run as seanrobertwright/lril-sdlc:<entrypoint>, for example seanrobertwright/lril-sdlc:implement. To customise the prompts for one project, copy the pack into it with archon plugin copy seanrobertwright/lril-sdlc-archon. The copies then run by their YAML names (lril-implement, …).

Using it

1. Set up the repo, once

archon workflow run seanrobertwright/lril-sdlc:setup --no-worktree

It picks GitHub when origin is on github.com, otherwise local markdown under .scratch/. Override with --input tracker=local. It writes Matt's own seed templates, so his skills work in the same repo outside Archon too. A code fence in them with no language is written as text, and a new CLAUDE.md or AGENTS.md opens with a top-level heading, so a repo that runs markdownlint on commit accepts setup's commit. Existing docs/agents files are kept (--input overwrite=true replaces them).

2. Shape an idea (interactive)

archon workflow run seanrobertwright/lril-sdlc:idea-to-tickets --branch feat/saved-cards "Let customers save a card at checkout"

Interactive workflows pause at a gate after every round. Read the round (the gate shows an excerpt; the full text is in the run's artifacts under shape/current-round.md) and answer it:

archon workflow approve <run-id> "Q1 yes. Q2: only signed-in Customers. Q3 yes"

"yes" accepts the recommended answer. When a round presents the final draft, approve with no comment to publish it exactly as shown, or with a comment to revise it. The gate's status line still reads "No completion condition met" at that point: the run completes on your bare approval. archon workflow get <run-id> --json shows where a run stands. The web console (archon serve) has the same gate controls.

3. Build it

# the whole spec, ticket by ticket, on the same branch
archon workflow run seanrobertwright/lril-sdlc:implement-spec --branch feat/saved-cards --input spec=#40 --detach

# or one ticket
archon workflow run seanrobertwright/lril-sdlc:implement --branch feat/saved-cards-03 --input ticket=#43 --input pr=true --detach

With the local tracker, pass paths instead: --input spec=.scratch/saved-cards/spec.md, --input ticket=.scratch/saved-cards/issues/03-saved-cards.md.

4. Look back

archon workflow run seanrobertwright/lril-sdlc:retro --input run=<run-id> --detach

On-ramps and upkeep

archon workflow run seanrobertwright/lril-sdlc:triage                      # what needs my attention?
archon workflow run seanrobertwright/lril-sdlc:triage --input target=#42   # triage one issue with me
archon workflow run seanrobertwright/lril-sdlc:diagnose --branch fix/double-charge "Checkout charges the card twice when the gateway times out" --detach
archon workflow run seanrobertwright/lril-sdlc:architecture --detach
archon workflow run seanrobertwright/lril-sdlc:code-review --input base=main --detach
archon workflow run seanrobertwright/lril-sdlc:wayfinder-chart "Rewrite billing on an event-sourced ledger"
archon workflow run seanrobertwright/lril-sdlc:wayfinder-step --input map=#12

Where this deviates from the skills, and why

• implement-spec builds the frontier serially, one fresh-context implementer per ticket on the integration branch, rather than as parallel subagents in separate worktrees. Each ticket passes a deterministic gate before the next one starts, and a failed run resumes at the open ticket. Parallel waves are a planned evolution.
• No human confirms test seams during AFK builds. /tdd asks you to confirm seams. Here they're agreed during idea-to-tickets (the /to-spec seam round) and read from the spec's Testing Decisions. A seam an implementer had to choose itself is reported as unconfirmed for the reviewer.
• Prototypes and research go to the run's artifacts, outside the repo, and are linked from the spec or ticket. A UI prototype that must run inside the project is recommended as a separate /prototype session on its own branch.
• Wayfinder research findings are posted as the ticket's resolution, rather than kept on a throwaway research/<name> branch.
• setup is deterministic. It applies Matt's recommended defaults instead of interviewing you; run /setup-matt-pocock-skills in Claude Code if you want the interview, or a tracker other than GitHub or local markdown.

Archon version notes

• Every AI node declares plugins: [mattpocock-skills@mattpocock]. Archon v0.11.1 loads all installed Claude plugins and warns that plugins is an unknown key. From the next Archon release, nodes load only the plugins they name, and this declaration is what keeps the skills available.
• Archon warns that plugin-qualified skills (mattpocock-skills:tdd) aren't on disk. That's expected: Claude resolves plugin skills itself.
• Gate replies reach a session through with: { reply: "$LOOP_USER_INPUT" }, and the command reads $INPUTS.reply. Archon v0.11.1 substitutes $LOOP_USER_INPUT into a loop_group body node's YAML fields, but not into the command file the node loads, so reading it there directly always gives an empty reply (coleam00/Archon#3954). Drop the binding once that is fixed.
• An interactive loop_group in Archon v0.11.1 pauses after its first iteration even when until_bash passes. On every later iteration, a passing until_bash ends the loop at once, with no gate. So each session's until_bash runs its validator with --gate. That passes only when the reply that opened the iteration is a bare approve (Archon records it as Approved) and the draft is unchanged since the last gate showed it.
• Interactive sessions use loop_group with interactive: true, which Archon marks deprecated in favour of a future gate composition. It's the supported mechanism today.

Developing the pack

cd tools && bun install && cd ..
tools/dev.sh            # validate every lril workflow, typecheck, unit + integration tests, all dry-run fixtures
tools/dev.sh test lril-implement

Archon discovers fixtures only under a project's .archon/workflows/, so tools/dev.sh mirrors the pack into a gitignored .archon/workflows/lril-sdlc/ first. tools/tests/local-flow.test.ts drives the real scripts end to end against a throwaway repo on the local tracker.

Each workflow lives in its own folder: <name>.yaml, commands/*.md (prompts), scripts/*.ts (deterministic nodes), bin/*.ts (validators bundled into a run for until_bash), and fixtures/*.stubs.yaml. Logic shared by several scripts lives in .shared/.

Credits and license

The methodology, the process each workflow encodes, and the templates in setup/templates/ come from Matt Pocock's skills (MIT, © 2026 Matt Pocock). See NOTICE.md. The skills themselves are loaded from his plugin at run time, not copied here. Learn the thinking behind them at aihero.dev/skills.

This pack is MIT licensed. See LICENSE.