Skill system · 14 Claude Code skills · Model tiering

14 agent skills Model tiering Persistent docs MIT

A multi-agent system built to make AI development repeatable.

AI coding assistants lose their context the moment a session is cleared, and the quality of the output goes with it. I split development into fourteen specialist skills, gave every subtask a model sized to its difficulty, and required each skill to write its result to a file before reporting back. Rebuilding the same instructions every morning stops being part of the job — and the token bill stops paying for it.

GitHub ↗

Client: Personal project · open source
Role: Lead developer & prompt systems architect
Year: 2026 — ongoing

Where it started

Single-model transient chats

Standard workflows pass every task — from business strategy down to a minor text replacement — to a single expensive model. Decisions live only in a temporary chat window, so the same setup gets explained again the next morning.

High API cost Lost context Ad-hoc prompts

What it became

Tiered models & saved assets

Tasks are triaged into five complexity tiers, and the bottom one — bulk text that never touches the repository — is offloaded to a local CLI at no cost. Every skill writes a structured file under docs/, so the context survives a session reset or a switch to another tool.

5 model tiers docs/ persistence 0-cost local run

The decision

Task complexity must determine model selection.

To settle the trade-off between speed, depth and cost, I gave up on relying on a single model. An orchestration hub reads the task it is handed and assigns it a tier. High-reasoning models are reserved for architectural and business judgment; mechanical work is spread across fast, light ones.

One timeline became a workshop with four rooms.

The old structure was not really a structure. Thinking, building and checking all shared one thread, so nothing showed how far a decision had actually got. The new tree gives each phase its own skills and its own output file — and it is the file, not the conversation, that carries the project forward.

Before

One chat session
 ├─ app concept       (typed by hand)
 ├─ UI design talk    (typed by hand)
 ├─ code & debug      (typed by hand)
 └─ session cleared   → everything gone

Scrolling back through old logs, or explaining the same thing again, was a daily cost.

After

HUB: superforge  (tiering + routing)
 ├─ 1. THINK  brain / biz / brand
 │            → product-idea.md, business-model.md
 ├─ 2. BUILD  ui / dev
 │            → design.md, plan.md
 ├─ 3. TEST   test / debug / a11y / secure
 │            → failforward.md, security.md
 └─ 4. SHIP   roast / verify / ship / handoff
              → ship-readiness.md, llms.txt

One long prompt became fourteen skills with a single responsibility each, so the constraints and checks a given job needs can be injected on their own.

Four decisions, in the order they were made.

Fourteen roles and one front desk

To stop a single prompt from running away with the whole job, I defined four phases — think, build, test, ship — modelled on how client work is actually staged, and placed fourteen skills inside them. The central superforge skill routes each task.

A cost-and-capability matrix, five tiers deep

Rules for when each model earns its place: Opus for judgment, Fable for long unattended runs, Sonnet for volume, Haiku for fast audits. Text work that never touches the repository moves to the local gemini CLI, which costs nothing to run.

docs/ as the single source of truth

So that a project can continue after the conversation is gone, every skill is required to write a specific format of Markdown or HTML into docs/ when it finishes. Switch tools or switch models, and the work resumes immediately.

Refusing the average answer

To avoid the safe, unremarkable answer a model defaults to, I built in a BreakBias engine that forces ideas past the obvious, and a FailForward memory that learns from past bugs and can be searched before a new one is diagnosed.

One sentence, and where it goes

The whole system seen from the typing end: what you actually enter, which skill takes it, in what order, and the file each one leaves behind. Every name on the right is a file that outlives the session.

The figure is SVG rather than a screenshot — the labels inside it are real text, and they change language along with the rest of the page.

The tier is chosen before any agent is spawned

Judgment costs more than volume, so the two are never billed the same. The bottom tier is the interesting one: work that needs no repository access runs on the local gemini CLI and consumes no Anthropic usage at all.

Model tier table. A judgment, A endurance, B volume, C routine and D bulk text, mapped across Claude, Gemini, Codex and Kimi. Tier D never touches the repository, so it stays off Anthropic usage entirely.

How AI was used

The model wrote the scaffolding. The opinions it could not.

More than eighteen configurations of the skill set were tried. The test for each was the same: clear the session completely, and see whether the next model could resume at the same quality from the written files alone.

What AI did

Wrote the boilerplate for all fourteen skills, generated the first pass of the documentation in five languages, and ran the test workflows.

Where it fell short

Followed faithfully, the output collapsed toward the polished but familiar — a design or an idea you have seen somewhere before. The sharp product decisions and the strict security and accessibility rules were the first things to fall out.

What I added

The BreakBias engine, which breaks the average idea on purpose
The VVA Matrix — visual density and tone made measurable on four axes
FailForward, which tags a bug's root cause so it is recalled next time
A sources ledger carrying verification dates, so changes to external models cannot rot the system quietly

Considered and dropped

A one-click generator

The appeal: say "build me an app" once, and let the whole pipeline finish in the background.

Why not: the human is shut out of the decisions that matter — tone, business model — and what comes back is a mountain of code too large to correct.

One giant prompt

The appeal: one file to manage, and the easiest thing in the world to distribute and update.

Why not: the context window fills, the instructions begin contradicting each other, and the model quietly skips the security checks and the UI token constraints.

What is actually in it

specialist skills, covering the whole development lifecycle

languages the README and documentation ship in

Tier D

runs entirely locally — bulk text work that costs nothing to run

What this design moves is a developer's morning. The time spent re-explaining the same premises to a model drops to zero, the decisions that used to evaporate stay written down, and the token bill is spent where judgment is actually needed.

Built with

Claude Code Skills · Antigravity IDE · Codex CLI · Gemini CLI
Opus 5 / Fable 5 / Sonnet 5 / Haiku 4.5 / gemini-3.6-flash
SVG architecture visualization · install.sh / install.ps1
BreakBias engine · FailForward debug memory

GitHub ↗

Two things this has not solved

Both are structural rather than incidental — they are the price of building on top of models someone else ships.

The inevitable decay of external model APIs

Model names and API specifications change every few months. A SOURCES.md ledger carrying verification dates keeps the drift visible, but the update logic is not automated — periodic manual or workflow checking is still the running cost of this system.

Visual feedback limits in a CLI agent environment

The HTML and CSS that superforge-ui produces is strong, but in a CLI-first agent environment there is a lag before a human can look at the rendered result and adjust it. Making headless-browser screenshots seamless is the piece still open.

Why it matters

Turn conversational chaos into persistent structure.

GitHub ↗ Explore other AI Tools →