The skills that run the factory,
not the session.
An agentic software factory is the development loop as an event-driven system, not a manual chat. Writing code is no longer the bottleneck. Verification is. The human does not leave the loop. They move to the ends: intent and direction.
npx @tech-leads-club/agent-skills install --skill tlc-discover tlc-plan tlc-implement the-judgeWorks with Cursor, Claude Code, Copilot, Windsurf, Cline and 14 others.
Event-driven, not a session
Work arrives from an issue, a user request, an incident alert or the backlog. Every item enters in the same shape: scope, acceptance criteria, owner.
Human at the ends
The human leaves the middle (execution) and holds the ends: define intent before code exists, then validate direction. A decision now costs a sentence. After two thousand lines, it costs a rewrite.
Verification is the bottleneck
Code got cheap. Proof did not. The factory spends its expensive steps on layered verification, not on typing. The human reads the PR for direction, not to hunt bugs the suite already caught.
Vertical slices
Build a thin end-to-end flow first, then deepen it. Left alone, a model builds horizontally and leaves nothing testable in the middle.
Layered verification
Cheap first (lint, types, unit). Expensive near the PR (integration, browser, mutation, security). Two sanity tests: run the agent-written test against pre-patch code, and discard edits it made to existing tests.
v1 is the core loop
Discover, plan, implement and the-judge ship today. Intake, triage and production feedback are stations on the same line. They come next.
How the factory runs
Seven stations on one line. v1 lights up research, plan, implement and the PR gate. Intake, triage and production are the same factory, still being built.
Work arrives as an event
Issue, user request, incident alert or backlog item. Same format every time: scope, acceptance criteria, owner.
Label is queue, lock and pause
An agent classifies: ready to build, needs a spec, missing information, wait. The label stops two agents grabbing the same issue, and it is the human pause point.
Define the problem
tlc-discover. Bug often skips this. A feature does not. Problem, success metric, architecture and signatures, before code exists.
Cut vertical slices
tlc-plan. Observable outcomes with concrete values. Each slice proves something a later agent can build without guessing.
Build and prove
tlc-implement. Isolated sandbox, own branch, vertical slice, cheap checks first. An independent verifier proves every check. The author never verifies their own work.
Judge the PR
the-judge. Evidence-first review, one consolidated GitHub review. Deterministic checks first, then judgment. Branch protection still requires a human. They read for direction.
Ship, watch, re-enter
Deploy and monitor. An incident or a piece of feedback becomes a new issue and re-enters stage 1.
The v1 skills
Four skills, one core loop. Discover decides. Plan cuts. Implement proves. The Judge reviews.
Interview the idea
Turns an unshaped problem into a verdict and a design document with literal decisions. The expensive judgment lives here: the problem, the success metric, the architecture and the signatures, before a line of code exists.
tlc-discover →Cut decided work into tasks
Takes work that is already decided and writes tasks a builder can act on without guessing. Each slice proves something. Criteria are observable outcomes with concrete values, not adjectives.
tlc-plan →Build, then prove it
Extracts a checklist from the plan, builds in vertical slices, and proves every check with an independent verifier. The author is never the verifier. Done is an exit code, not a self-report.
tlc-implement →Review with evidence
Evidence-first PR judge. Runs lint, types and tests first, researches current docs, then posts one consolidated GitHub review. Every finding carries a citation. The verdict is APPROVE, COMMENT or REQUEST_CHANGES. The human still merges.
the-judge →Software factories are not new
The idea dates to 1968. What changed is which station on the line became an agent, and where the bottleneck went. Code got cheap. Proof did not.
Before
Human in the middle
Execution is the job. The expensive hour is writing the code.
Work lives in a session
A chat is the queue, the lock and the memory. Nothing arrives in a shared format.
Code is the bottleneck
Verification is a review bolted on at the end, if it happens at all.
Now
Human at the ends
Define intent before code exists. Validate direction after proof. Execution is an agent station.
Work arrives as an event
Issue, Slack, alert, backlog. Same shape every time, so the next station does not improvise.
Verification is the bottleneck
Cheap checks first, expensive ones near the PR. The human reads for direction, not to hunt bugs.
Two sanity tests at the verification station
The pre-patch test
Run the test the agent wrote against the code from before the patch. If it still passes, it tests nothing.
Do not let it rewrite the suite
Discard edits the agent made to existing tests. A green suite that it loosened is not proof.
The human doesn't leave the loop. They change position.
v1 covers research, plan, implement and PR review. Intake, triage and production land in later versions of the same line.
Start the factory with the core loop
Four skills, one command, works with your agent today.
npx @tech-leads-club/agent-skills install --skill tlc-discover tlc-plan tlc-implement the-judge