AI development harness

Your agents write the code.
Spaccy writes the process.

The control plane for AI-assisted development: see, govern and audit what agents do in your code — specified beforehand, traceable while it runs, auditable afterward. On the repository you already have, with the agent you already use.

Request early access How it works

11: supported agent runtimes
50: ready-made commands, from discovery to video
0: lock-in — everything in files, in your own repository

The problem

Speed went up. Visibility went down.

Adopting AI agents multiplied the volume of code your team ships. What didn’t keep up was the ability to answer what was decided, why, and who approved it.

The decision died in the chat

The reasoning behind every choice ended up in a conversation nobody archives. Two weeks later, not even the person who asked can reconstruct the reasoning — and the next agent starts from zero.

The spec and the code drift apart, quietly

The agent delivers what it understood, not what was agreed. Without an acceptance criterion written beforehand, the drift only surfaces at review — when it surfaces at all.

There’s no trail

Who ran what, in which repository, with which agent, under which approval? Without an answer, there’s no honest review — let alone an audit.

How it works

Three steps, and your repository becomes the project’s memory

In engineering, a test harness runs under controlled conditions, collects what happened and checks it against what was expected. Spaccy applies that shape to the agents’ work — and all you need are the commands below.

01
Specify beforehand
You describe what you want; Spaccy turns it into an analysis, a proposal and a specification versioned in your repository. When the problem isn’t clear yet, the study comes before the solution — and the acceptance criteria are written before the first line is generated. The agent gets a contract, not a hunch.
/analysis/proposal/ai-spec
02
Trace while it runs
The implementation runs in an isolated copy of your working tree, and nothing gets written without your approval. At every step, progress is read from the repository and shown in the cockpit — nobody has to update a status field.
/implement/pipeline
03
Audit afterward
Every delivery is reviewed against its own specification, decisions become architecture records, and whatever’s left over becomes a follow-up with an owner and a due date. Six months later, the answer to “why is this like this?” is sitting in the repository.
/review/followup

The cockpit

Everything that happened, in one place

Spaccy Studio reads your repository and shows the real state of the work — with nobody filling in a status field, with no meeting needed to find out where each thing stalled.

Which stage every feature is at, what got stuck and what’s still left
Spec, review and architecture decision, linked to the feature that produced them
Follow-ups and deprecations with a due date — not just good intentions
Everything the agents ran, what they generated, and who approved it

Harness Studio cockpit showing the project context, in-progress features and what needs attention. — A real capture of the cockpit — the data is this project’s own, not a sample.

Bring your own agent

Spaccy doesn’t replace your agent — it governs all of them

Eleven supported runtimes today, behind the same interface. Switching agents tomorrow doesn’t cost you your process, and your process doesn’t stay hostage to one model vendor.

Claude Code
Claude Agent SDK
Codex
Copilot
Gemini CLI
OpenCode
Aider
Qwen Code
Kimi Code
MiMoCode
Agy

Why Spaccy

What you get

Works with the agent you already use

Spaccy doesn’t compete with your agent — it orchestrates and watches it. Eleven runtimes behind the same interface: switch models or vendors without losing your process, your history or your specs.

Governance that doesn’t rely on discipline

Human approval before every write, role-based permissions, deprecations with a due date, and a trail of who ran what. The process is executed by the tool — not remembered by a person at the end of a long day.

When it doesn’t know, it says so — not made up

Critical steps run on deterministic engines: when context or a precondition is missing, the flow stops and states what’s missing. That’s the difference between a reproducible process and “write the prompt and hope for the best.”

Everything in files, inside your own repository

Specs, decisions, follow-ups and history version alongside the code, readable by humans and by machines. Nothing leaves your machine, and there’s no lock-in: if you stop using Spaccy, the project’s memory stays yours.

Drops into a project that already exists

You don’t need to start from zero. Spaccy scans the documentation and code of a project already in flight, builds the context map, and reconstructs the specifications of what’s already been built — all anchored to the real code.

Documentation ships along with the code

Technical and user manuals, use cases, team training and narrated video, generated from the project itself — and refreshable when it changes. Documentation stops being the debt nobody pays down.

Explore

Seven angles worth the visit

The workflow from the inside, the copilot inside your own application, how the process is dialed to your team, security built into the flow, the documentation Spaccy writes for you, the layered view of your system, and the governance of what agents do — each on its own page.

Workflow

The four-command cycle, customization by team and by person, and requirement-to-test traceability once it’s done.

See the workflow from the inside

Copilot

The copilot inside the application you’re building: sees the screen, the error and the element you pointed at — and reaches the file that generated it.

See the copilot in the app

Methodology

Three rigor tiers to match ceremony to risk, and three methodologies that speak your team’s language — agile, enterprise or standard.

See how the process is dialed

Security

Threat and privacy modeling at design time, code audit, a scan of the live application, and a deterministic gate before release.

See security in the flow

Materials

Manual, use cases, training, video and deep explanations — generated from your own project, not written by hand.

See what Spaccy writes for you

Vision

The architecture, the domain and the decisions of your system, extracted from the code and navigable in layers — from the diagram down to the line.

See the vision of your system

Governance

Human approval before every write, no lost work, and a full trail of who ran what.

See how the process becomes visible

Your agents write the code. Spaccy writes the process.