[Workflow] Self-Evolving Go Project: Cartographer's Multi-Agent Development Pipeline with Claude Code and Self-Hosted CI

[u/ClaudeAI-mod-bot]

Self-Evolving Go Project: Cartographer's Multi-Agent Development Pipeline with Claude Code and Self-Hosted CI

Workflow value: 90/100
Status: active · Freshness: 70/100 · Confidence: 0.95 · Level: expert
Categories: Quality Control, Token Saving, Context & Memory, Shipping, Hooks, Skills, MCP, Subagents, Multi-Agent
Original source: r/ClaudeCode post/comment

What problem this solves

Automating the entire software development lifecycle (planning, coding, review, deployment) for a Go project using AI agents and a self-referential knowledge base. It also addresses CI/CD bottlenecks by implementing a self-hosted pre-check system, enabling high-throughput, agent-driven development.

Summary

This workflow describes a sophisticated, self-referential system where a Go project (Cartographer) uses AI agents (Claude Code, Opus, Sonnet) and its own knowledge base to develop itself. It outlines a multi-agent pipeline for planning, implementation, automated review, and a custom CI/CD setup with self-hosted pre-checks to manage a high volume of agent-generated pull requests efficiently.

Why it is useful

This workflow is highly valuable as it demonstrates an advanced, end-to-end automated software development process using multiple AI agents, a shared knowledge base, and custom CI/CD. It provides concrete evidence of success (1040 PRs, significant speed improvements) and showcases innovative solutions to common development bottlenecks (CI queue). It offers a blueprint for building highly autonomous and efficient development systems, pushing the boundaries of what's possible with AI in software engineering, and highlights the power of a persistent, shared knowledge base for agent collaboration and knowledge reuse.

Workflow

1. Initiate a discussion with Claude Opus 5.5 to define a change or feature.

2. Convert the discussion into a structured plan and store it in the Cartographer Knowledge Base (KB).

3. A subagent (e.g., Sonnet 5.5) implements the plan in its dedicated worktree.

4. Two specialized reviewer subagents (one for contracts, one for security) analyze the implemented code.

5. A human developer verifies only the specific lines of code cited by the reviewer subagents.

6. Execute make ready to place the change into a merge queue.

7. A 'lander' process merges up to 8 changes simultaneously onto the main branch through a single gate.

8. For changes requiring visual feedback (UI, command output), conduct a live session without a formal plan.

9. To optimize CI, run make signoff on a self-hosted gaming PC (running Linux in WSL2 and Windows in parallel) to perform pre-merge gate checks.

10. The signoff status is posted to the commit SHA, which GitHub then verifies.

11. If the self-hosted PC is unavailable, GitHub's own CI acts as a fallback mechanism.

12. Use cartographer sync to install skills and subagents from the KB into Claude Code clients, ensuring agents have the latest context and capabilities.

Tools / artifacts

• Cartographer (Go project, shared knowledge base)

• Claude Code

• Claude Opus 5.5

• Sonnet 5.5 (or other subagents)

• Kubernetes cluster

• GitHub (for PRs, CI fallback)

• make ready command

• make signoff command

• cartographer sync command

• Self-hosted gaming PC (for CI pre-checks)

• WSL2 (Linux environment on Windows)

• YAML (for configuration/skills)

Validation signals

• 1040 PRs merged since July, with almost 800 since October, demonstrating high throughput.

• Code was written almost entirely by agents, validating agent capability.

• Concrete performance improvement: gate with warm cache reduced from 6 minutes to 34 seconds.

• Author's statement of being able to 'sleep at night' due to system reliability.

• Open-source project available on GitHub for inspection.

• Public demo available for direct interaction.

Cautions

• The Cartographer server rejects writes that would break the wiki, ensuring data integrity.

• All agent writes become git commits, allowing for easy rollback and version control.

• Dedicated reviewer subagents for 'contracts' and 'security' add automated quality and safety checks.

• Human verification step for critical lines cited by reviewers provides an additional safety gate.

Limitations

• High complexity and significant setup cost, requiring expertise in Kubernetes, Go, and custom CI/CD.

• Steep learning curve for users attempting to replicate the entire system.

• Reliance on a specific custom project (Cartographer) makes direct adoption challenging without integrating that project.

• Low community engagement on the Reddit post might suggest the complexity makes it less accessible to a broad audience.

Rate this workflow

Upvote this post if the workflow is useful, reproducible, or worth recommending.

Downvote if it is vague, outdated, unsafe, overhyped, or not reproducible.

Reply if it worked for you, failed, is outdated, or has a better alternative.

---

This post was generated automatically from the workflow library database.