Skill Bill

Hand Skill Bill a spec and get back a merge-ready PR — planned, implemented, stack-specialist-reviewed, audited against the spec, and quality-gated. AI coding agents are powerful but inconsistent: the same prompt yields different work every run, with no process holding it together. Skill Bill gives yours the structure of a real engineering process and runs it the same way every time, across whichever agents you use.

A /bill-feature run carrying a spec through every phase to a merge-ready PR — and because the run is interrupted mid-flight (usage limit, crash, lost connection) it also shows the part most demos hide: it resumes from durable workflow state and finishes, nothing lost. The demo is generated, not hand-recorded (docs/assets/generate_demo_gif.py), so it never goes stale.

Built with itself. Skill Bill's own features ship through this pipeline. #177 was planned, implemented, reviewed, and written up by the same process described here — click through and judge the actual output, not a demo.

Who it's for: developers and teams who want their AI agent to implement whole features with the rigor of a real engineering process — planned, reviewed, audited, and quality-gated — instead of one-off code they have to babysit and re-review. You still review the final PR; the point is that what reaches you was already planned, reviewed, and checked, not dumped on you raw. Probably overkill if you only want quick single-file completions. Pre-1.0 and solo-maintained.

Quickstart (≈60 seconds)

curl -fsSL https://raw.githubusercontent.com/Sermilion/skill-bill/main/install.sh | bash

Downloads and checksum-verifies the prebuilt runtime for your OS — no clone, no JDK, no Gradle. Needs only curl, tar, unzip, and either shasum or sha256sum on macos-arm64, macos-x64, windows-x64, or linux-x64.

Don't pipe a stranger's script straight into your shell? Read it first:

curl -fsSL https://raw.githubusercontent.com/Sermilion/skill-bill/main/install.sh -o install.sh
less install.sh   # it's a plain shell script — read it
bash install.sh

skill-bill version
skill-bill doctor
skill-bill update-check
skill-bill update

If skill-bill is not found, the launcher directory (~/.local/bin by default) isn't on your PATH. Add it — export PATH="$HOME/.local/bin:$PATH" — and put that line in your shell's rc file (~/.bashrc, ~/.zshrc, ~/.config/fish/config.fish).

Contributors or unsupported hosts: clone the repo and run ./install.sh --from-source (requires a JDK). Any host not in the four prebuilt targets falls back to this automatically.

Why it exists

AI coding agents don't follow a consistent process. The same prompt produces different work each run — sometimes it reviews thoroughly, sometimes it skims; sometimes it follows your conventions, sometimes it invents new ones; sometimes it finishes the feature, sometimes it wanders off. That is fine for a quick completion and a real problem for shipping a feature you have to stand behind.

Dropping skill files into ~/.claude/skills/ doesn't fix that — they're just prompts the agent can follow or skip, with nothing checking. Skill Bill runs a curated skill set as a structured, enforced process instead: a durable runtime that owns each feature run, a fleet of specialist subagents, contracts that fail loudly when skills drift, and the same skill set working across every agent. The skills carry the engineering judgment; the runtime makes the agent actually follow it on every run.

What you get

A feature implemented end-to-end from a spec — planning, implementation, stack-specialist review, completeness audit, and quality gates, all the way to a merge-ready PR. That is the headline. Everything else exists to make it reliable, repeatable, and yours:

• the same governed skill set installed across every agent you use — verified end-to-end on Claude Code and Codex
• a governed contract that fails loudly when skills drift instead of silently going stale
• durable, resumable workflow state so long-running multi-phase skills survive crashes and context compaction
• automatic decomposition of oversized work into resumable subtasks the runtime tracks for you
• structured telemetry through a pluggable proxy you can self-host
• per-project overrides so the same skill behaves differently per repo without forking
• per-module memory so institutional knowledge lives next to the code
• a Compose Desktop UI for authoring, validation, scaffolding, and install — no CLI required

Capability deep-dive →

Reference pack

Skill Bill ships complete Go, Kotlin/KMP, PHP, and Python packs — the stack-specific intelligence that lets the system review and check your code like someone who actually knows that stack. Use them directly if they fit, tune them to your conventions, or add a pack for your stack.

Daily entry points:

• /bill-feature prepares the feature spec, then routes to implementation or the goal loop
• /bill-feature-spec prepares governed single-spec or decomposed feature-spec artifacts before implementation
• /bill-code-review routes to the matching platform review stack (the stack-specific review skills are internal sidecars, not separately invocable)
• /bill-code-check routes to the matching stack-specific checker (the stack-specific checker skills are internal sidecars, not separately invocable)
• /bill-pr-description generates PR text and QA steps
• /bill-feature-verify verifies a PR against a spec or design doc

Shipped platform packs:

• kotlin — baseline Kotlin review and quality-check behavior
• kmp — Kotlin baseline plus Android/KMP depth and governed add-ons
• go — Go services, libraries, CLIs, modules, APIs, persistence, concurrency, security, testing, Go-rendered UI, UX/accessibility, and quality-check behavior
• php — PHP applications, services, Composer projects, APIs, persistence, security, testing, server-rendered UI, UX/accessibility, and quality-check behavior
• python — Python applications, libraries, CLIs, APIs, persistence, security, testing, UI, UX/accessibility, and quality-check behavior

Full skill catalog:

Learn more

• Getting Started: install flow, CLI surfaces, agent support tiers, and MCP tool groups
• Getting Started for Teams: rollout guidance, customization strategy, and adoption patterns
• Capability Deep-dive: the full system — one-shot install, durable workflows, platform packs, decomposition, Desktop UI, telemetry, overrides, memory, and governance
• Skill Source And Generation Model: content.md vs generated SKILL.md, support pointers, install staging, and native-agent generation
• External Addon Sources: overlay private or team-specific review add-ons onto an installed pack, kept out of the shared repo
• Review Telemetry: telemetry contract, learnings, local DB usage, and remote proxy stats

License

MIT