Claude Code plugin

An AI workflow that
holds its shape

An unconstrained coding agent produces code that looks right — plausible, large, and wrong in ways you only find at review. BigIn Skills adds the structure that makes AI work reviewable: an approved spec before code, an independent verifier that never reads the implementer's own summary, and commit gates that can't be switched off.

5 stack profiles — Nuxt · Next · Go · Node · generic 13 skills, 7 agents No runtime dependencies

Three ways AI coding goes wrong

Each one has a mechanism pointed at it — not a prompt asking nicely.

01

It starts before the shape is agreed

You get a large diff built on an assumption nobody stated, and you find out at review.

Spec gate — an approved PLAN.md, enforced by a hook, before any non-trivial edit lands.
02

It marks its own homework

"I implemented the feature and it works" is a self-report, not evidence.

Independent verifier — a fresh agent reads the diff itself, never the implementer's account of it.
03

It forgets, expensively

Every session re-derives the same context, and re-derives it differently each time.

Knowledge bundle — versioned concept files with an index-first read protocol, validated at commit.

Six steps, two decisions

The loop every non-trivial task runs through. Most of it is automatic — you answer twice.

  1. Scope

    One sentence, before any code.

  2. Spec gate you approve

    What changes, edge cases, security, and an explicit not in scope.

  3. PLAN.md

    The approved spec plus a task table, on disk. The working contract.

  4. Implement

    Routed to the cheapest tier that can do the job — quick, standard, or deep.

  5. Verify capped fix loop

    A fresh agent audits the diff against the plan. On a fail, back to implement. Three rounds maximum.

  6. Review and Cleanup you decide

    A human pass, /code-review, or both — then distil what's durable and delete the plan.

What's inside

Thirteen skills and seven subagents. You invoke almost none of them by name — they trigger on intent.

01

Governance

bigin-harness-setup scaffolds a CLAUDE.md brief, path-scoped rules, and commit-time gates into an existing repo. Five stack profiles.

02

The task loop

task-workflow, debug-workflow, and write-tests — spec to verified diff, systematic debugging with triage, and tests that match your existing style.

03

Cost routing

model-router scores capability and verification separately, then routes to the tier that fits. Three ladders, from cost-first to frontier.

04

Knowledge

knowledge-distill pins a library's docs at an exact commit and audits the result. sprint-distill compresses what the team learned — never appends.

05

Scaffolding

New-project generators for Nuxt 4, Next App Router, Go (Gin + GORM), and Fastify — each wired to the same harness on the way out.

06

Enforcement

Deterministic Node guards: spec gate, Conventional Commits, a regression test on every fix, and a three-stage prompt-injection gate with a canary.

Built on one principle

Every rule here is enforced by something that isn't the model. A rule an agent can talk itself out of is a suggestion — and suggestions decay.
~1.7k
tokens loaded per session, budget-checked at commit
0
runtime dependencies — guards are plain Node
3
verify rounds maximum, then it stops and asks

Start with the handbook

Why the harness exists, the five concepts behind it, setting up a repo, the daily loop, and the practices that decide whether it works for a team. One page, no signup.

claude code
/plugin marketplace add tammai/bigin-skills
/plugin install bigin-skills@bigin