Claude Code + Colign: From spec to working code in 10 minutes

What if your AI coding agent could read your team's spec directly — no copy-pasting, no context loss, no manual bridging? That's exactly what happens when you connect Claude Code to Colign via MCP.

Here's a real walkthrough of the entire flow.

Prerequisites

• Claude Code installed and configured
• Colign account with an API token (or OAuth 2.1 for SaaS)
• A project with at least one Change in "Ready" state

Step 1: Connect Claude Code to Colign (2 minutes)

Install the Colign plugin for Claude Code:

```bash claude plugin add colign/plugin ```

Or configure the MCP server directly in your settings:

```json { "mcpServers": { "colign": { "type": "streamableHttp", "url": "https://mcp.colign.dev", "headers": { "Authorization": "Bearer your-api-token" } } } } ```

Run `/colign:onboard` to verify your connection.

Step 2: Read the spec (1 minute)

Use the `/colign:explore` skill to browse your project:

``` /colign:explore ```

Claude Code lists your projects and Changes. Select the Change you want to implement. The agent reads:

• Proposal — Problem, Scope, Out of Scope, Approach
• Acceptance Criteria — Given/When/Then scenarios
• Tasks — Broken down implementation steps
• Project Memory — Domain rules and constraints

All of this arrives as structured data via MCP. No copy-pasting.

Step 3: Plan the implementation (2 minutes)

Use `/colign:plan` to have Claude Code create an implementation plan:

``` /colign:plan ```

The agent reads the spec and generates:

• Architecture decisions based on the Approach section
• File-by-file implementation plan
• Task breakdown aligned with the spec's tasks

Review the plan. Adjust if needed. This is the last human checkpoint before code generation.

Step 4: Implement (4 minutes)

Use `/colign:implement` to start coding:

``` /colign:implement ```

Claude Code works through each task:

1. Reads the task description and acceptance criteria
2. Writes the code
3. Updates the task status to "in_progress" → "done" via MCP
4. Moves to the next task

You can watch in real-time as tasks flip from "todo" to "done" in your Colign dashboard.

Step 5: Verify and complete (1 minute)

Use `/colign:complete` to wrap up:

``` /colign:complete ```

The agent verifies:

• All tasks are marked "done"
• Acceptance criteria are satisfiable by the implementation
• No scope creep beyond the spec's boundaries

If everything checks out, the Change advances to the next workflow state.

What just happened

In 10 minutes, you went from a team-approved spec to a working implementation. Here's what's different from the traditional workflow:

| Traditional | With Colign + Claude Code | |-------------|--------------------------| | Copy spec from Notion | Agent reads spec via MCP | | Manually explain context | Project Memory provides context | | Hope AI understands scope | Out of Scope section prevents drift | | Manually track progress | Tasks auto-update via MCP | | Manually verify completeness | Acceptance criteria checked |

Zero copy-paste. Zero context loss. Full traceability.

The key insight

The 10 minutes isn't the impressive part. What's impressive is the accuracy. Because the AI agent has direct access to the structured spec, acceptance criteria, and project memory, it builds the right thing the first time.

No rework cycles. No "that's not what I meant." No integration failures because developer A read a different version of the spec than developer B.

This is what spec-driven development looks like in practice.

FAQ

Q: Does this work with Cursor or other AI tools? A: Yes. Any MCP-compatible tool can connect to Colign's MCP server. The workflow is the same.

Q: What if the spec is wrong? A: That's why specs are reviewed and approved before dispatch. Catching errors at the spec stage is 10x cheaper than catching them in code.

Q: Can I modify the code after generation? A: Absolutely. The generated code is yours. Edit, refactor, extend as needed. The spec remains the source of truth for what was intended.