Integrations

Use speccoder from Zed and JetBrains over the Agent Client Protocol, give it MCP tools, let Copilot, OpenCode, Claude Code, Codex or Gemini CLI make the attempts, run it in CI, and as a Spec Kit workflow step.

Editors (ACP)

speccoder acp speaks the Agent Client Protocol on stdio, so editors with ACP agents — Zed, JetBrains IDEs and others — can drive speccoder. In Zed:

{
  "agent_servers": {
    "speccoder": { "command": "speccoder", "args": ["acp"] }
  }
}

• Tasks and the model’s tool calls appear as the editor’s tool calls; during /run the feature’s tasks are the editor’s plan.
• A call that needs a person becomes the editor’s permission dialog, with the inline prompt’s content and choices. Rejecting asks for a reason in a form when the editor can show one; dismissing the dialog stops the task.
• Cancelling stops a feature run before its next task.
• The model and key come from speccoder.toml and the environment, as on the command line.

MCP servers

Give the model tools from any stdio Model Context Protocol server:

[mcp.notes]
command = ["notes-server", "--stdio"]
allow = ["list_notes"]        # called without approval
deny = ["delete_everything"]  # never offered

• Servers start in the worktree for each task, inside the sandbox, with a scrubbed environment; their tools appear to the model as mcp__<server>__<tool>.
• Every call of a tool not in allow needs approval; whatever a tool writes is still caught by the diff audit and the verifier.
• Allowed tools stay what you reviewed. The first time speccoder sees an allowed tool it records a digest of its name, description, schema and annotations. If the server changes any of that, the run warns and each call of the tool needs approval until a person approves one.

External agents

Let another coding agent make the attempts while speccoder decides its calls and judges the result:

[executor]
agent = "copilot"    # or "opencode", "claude", "codex", "gemini"

• Any other ACP agent: kind = "acp" with argv = ["my-agent", "--acp"]. A program that is not an ACP agent: kind = "command" with argv — the task on stdin, its summary on stdout, judged from the diff alone.
• model selects the agent’s model where it offers a choice; mode keeps a permission mode of your choosing; timeout_secs (default 1800) bounds one attempt — then speccoder cancels the turn and stops the agent.
• speccoder run --agent opencode (and the app’s Run ▾ menu) picks the agent for one run; speccoder.toml is unchanged. speccoder doctor --agents and Settings › Executor show each agent as installed, signed in and asks first, with the one step that fixes a missing tick. speccoder never signs an agent in: a sign-in it needs stops the task with EXECUTOR-LOGIN and the agent’s own login command.

What speccoder governs.

• Before the first prompt it puts the agent into its ask-first mode, unless you set mode. OpenCode starts with every permission rule set to ask (merged into your OPENCODE_CONFIG_CONTENT).
• A request naming a credential, a protected file or a place outside the worktree is refused; so is a fetch.
• Everything else the agent does itself asks you: reads, edits, searches and commands (they run outside the sandbox). For this task allows exactly that request again.
• On the first read you can allow plain reads for this task: one regular file in the worktree, by read or a lone cat/head/tail/wc. Not a link, nothing under .git/ or git-ignored, no credential and nothing that would be masked.
• speccoder answers allow once, never always. A call that needs you waits at the terminal, in Needs You or for task approve; that time does not count against timeout_secs.
• Files and commands the agent runs through speccoder’s file and terminal access get the protected paths, masking, the command policy and the OS sandbox.

What stays outside.

• The agent is its own process with your environment. What it does without asking never reaches speccoder: some agents read files unasked, and an allow rule in its own settings (Claude Code’s permissions.allow, also in a repository’s .claude/settings.json; Gemini’s tools.allowed; Copilot’s allowed tools) skips asking.
• speccoder checks afterwards: an edit or command reported done without an allowed request marks the run decides alone. A switch to a mode that decides alone, or one no recording knows, cancels the turn; an agent version no recording knows says not known whether it asks.
• Decisions rest on what the agent declares: what it runs may differ from what it asked, and a call it never reports is not seen.

The worktree, the acceptance tests, the diff audit, the checks, the verdict, retries and committing are the same as for every attempt. A final message starting with BLOCKED:, or a turn that changed nothing, is an honest stop. See security.

CI and scripting

--json (one result object), --events (JSON Lines ending in that object) and the exit codes are stable contracts with published schemas; see the CLI reference. Exit 23 always means “a person is needed”. For unattended runs use --no-prompt: a call that needs approval waits for task approve instead of prompting.

GitHub Actions

Under GITHUB_ACTIONS=true, run and report append the feature’s report as Markdown to the job summary and annotate tasks: a warning for regression only and suspected gaming, an error for failed and blocked tasks. They stay within GitHub’s limits: ten annotations of a kind per step (a notice counts the rest), a summary under 1 MiB (the least important sections left out, and said so). The model’s own words appear in neither.

- run: speccoder run --no-prompt
  env:
    ANTHROPIC_API_KEY: …   # from the repository's secrets

speccoder report --markdown prints the same Markdown anywhere. Pull requests: GitHub; checking evidence on them: the evidence check. Spec Kit workflow steps: planning.

Edit this page