SpecD Guide: Compiled Context and Deterministic Merging for Team Specs

Most spec-driven tools were built for individuals and small teams. SpecD — installable as @specd/specd — is a ground-up redesign aimed at the gaps that appear when a team runs spec-driven development: context that's scattered across files, changes that conflict, and validation that quietly depends on the LLM's mood.

SpecD's pitch is professional-grade determinism. Three ideas define it:

1. Compiled context — specs aren't "discovered" by the agent reading the repo; they're computed and delivered, in the right shape, for the task at hand.
2. A multi-language code graph — TypeScript, Go, Python, PHP — so spec changes carry real impact analysis: this spec change touches these files.
3. Deterministic merging and validation — spec conflicts are resolved by rules, not by asking the LLM to figure it out.

The three pillars

Compiled context

In most spec workflows, the agent reads a spec store and hopes it noticed the relevant parts. SpecD inverts that: specs are compiled into the context that gets delivered to the agent — the right specs, pruned to the task, with the relevant code graph attached. The agent doesn't hunt; it receives. For teams running many agents on one codebase, this removes a whole class of "the agent didn't see the spec that governs this module" failures.

Multi-language code graph

Spec changes are matched against a code graph spanning TypeScript, Go, Python, and PHP. When you modify a spec, the tool knows which source files the change impacts — and it can deliver that impact analysis to the implementing agent, the reviewer, or the human. This is impact analysis as a product feature, which is rare in the spec-driven space (most tools stop at "here's the spec").

Deterministic merging and validation

Here's the philosophical difference from the LLM-first tools: when two changes touch the same spec, SpecD resolves or flags the conflict with deterministic rules, not by asking an LLM whether they're compatible. Validation works the same way — schema-defined workflows (a customizable schema.yaml), lifecycle hooks, and human approval checkpoints are enforced by code. If the ecosystem's other tools delegate the judgment to the model, SpecD's answer is: judgment belongs in rules and in humans.

Working in practice

• Plugins for agents: SpecD ships plugins for Claude Code, Copilot, Codex, and OpenCode — the agent gets the compiled context automatically.
• Customizable workflows: the schema.yaml lets teams define their own spec lifecycle — which artifacts, which gates, which hooks fire when.
• Lifecycle hooks and human checkpoints: automated steps (lint, build, test) run at defined points, and required human approvals are enforced rather than suggested.
• Multi-workspace support: coordinated repos and monorepos are first-class — the same spec system spans a repo group, not just one directory.

Where SpecD fits

Choose SpecD when:

• You're a team (not a solo dev) running spec-driven development across several repos.
• You've been burned by LLM-dependent validation — you want spec conflicts and gate checks decided by rules.
• Your project spans multiple languages and you want real impact analysis on spec changes.
• You want the workflow itself (schema.yaml) to be a configurable artifact, not a fixed pipeline.

Skip it when:

• You want minimal ceremony on a personal project — specdd or OpenSpec is a better fit.
• You're standardizing on the industry-standard workflow — GitHub Spec Kit has the ecosystem and the extensions; SpecD has the engineering.
• You need the full lifecycle team model with adversarial review — that's BMad's territory.

Quick comparison

| | SpecD | GitHub Spec Kit | OpenSpec | |---|---|---|---| | Context delivery | Compiled and pruned per task | Artifacts, read by the agent | Spec store, agent-driven | | Conflict resolution | Deterministic rules | Not addressed explicitly | Compiler-level delta conflict detection | | Validation | Rule-based gates + human checkpoints | Constitution compliance gates | None | | Team/scale focus | Multi-repo, multi-language, plugins | Single repo, branch-per-feature | Single repo, change-per-feature | | Setup | npm install + plugins | uvx/pipx CLI | npm install, ~5 min |

For the broader picture of where SpecD sits, see the complete spec-driven coding guide and the Spec Kit vs OpenSpec vs BMad comparison.

Getting started

npm install -g @specd/specd
# scaffold a workflow schema, install the plugin for your agent,
# and propose your first spec change

The schema.yaml is the thing to customize first — it's your team's process, made executable. And if you're weighing SpecD against the governance-heavy options, the spec-driven vs vibe coding comparison explains why teams are adopting this at all.