Ada
The semantic authority for your software — from first idea to last commit.
Not a chatbot. Not a code generator. A compiler. It takes intent as input and governed artifacts as output. Claude Code builds against those artifacts.
What Ada is not
Clear the assumptions first.
Not a chatbot
Ada doesn't do open-ended conversation. It runs structured elicitation sessions with a specific goal: resolve the blocking unknowns before they become wrong code.
Not a code generator
Ada produces governed blueprints. Claude Code generates the code. Ada is the layer above the execution layer — not inside it.
Not a one-shot tool
The compiled world model persists. It's navigable. You can query it months later — "what did the architecture stage decide about payments?" — and get an authoritative answer.
Not a prompt wrapper
Ada makes autonomous implementation decisions at the semantic level. It doesn't surface technical choices to the user — it surfaces semantic ones. The output is a governed artifact, not a better prompt.
The pipeline
Four phases. Each reduces ambiguity in one dimension.
Intent
You describe what you want to build — at whatever level you think in. Ada infers technical choices from conceptual descriptions. It doesn't ask which framework. It asks what the system should do.
Elicitation
Ada identifies blocking unknowns — the things it genuinely doesn't know that would cause the wrong system to be built. It asks the minimum set of questions to resolve them. Semantic questions, not technical ones.
Compilation
Ada produces the canonical semantic model: goals, entities, processes, and architecture — encoded as governed artifacts. Each artifact is addressable by provenance. Every decision traces back to intent.
Execution
Claude Code receives the governed blueprint and builds. Ada's constraints are in the artifacts — not in the prompt. Claude Code can't build outside Ada's decisions because those decisions are structural, not conversational.
The world model
Persistent artifacts, not ephemeral context.
Most AI tools produce ephemeral output — a response in a conversation. Ada produces a world model: a persistent, navigable, provenance-addressed artifact store.
intent-graph/ Your goals, constraints, and unknowns — as a structured artifact entity-map/ The canonical entities of your domain process-flow/ State machines and workflows that define how entities move blueprint/ The governed architecture and component mapping — authoritative verification/ Drift detection — does the codebase still match original intent? Claude Code reads this on every session. Not a static file — a live knowledge graph. Every artifact traces to the raw intent it came from.
Ada + Claude Code
The governance model.
Ada and Claude Code are not competing — they're layered. Ada governs. Claude Code executes. The interface between them is the artifact store.
CLAUDE.md + agents + hooks
Ada writes CLAUDE.md as a pointer to the world model — not a spec dump. Agents are scoped by bounded context. Hooks enforce entity invariants at every tool boundary. These are laws, not suggestions.
Structural constraints
Ada's artifacts constrain what Claude Code can build. The governed blueprint tells Claude Code what entities exist, what processes are valid, what the architecture is. It can't deviate — the constraints are structural.
Parallel workstreams
You can run Ada compiling product strategy for one initiative while Claude Code builds an entirely different part of the system. Two abstraction levels. Both governed. Both traceable.
Where Ada is now
Honest about current state.
Compilation
Intent → elicitation → governed blueprint → Claude Code execution. The full pipeline runs today.
Elicitation
Structured dialogue before compilation. Ada resolves blocking unknowns before they become wrong code.
World Model
Persistent artifact store. Navigable. Provenance-addressed. CLAUDE.md becomes a 3-line pointer to the manifest.
Ongoing Authority
Ada as semantic guardian on every commit. Drift detection. Impact analysis. "Does this change align with what the system was meant to be?"