zircote

If you told me at the start of 2025 that I’d be shipping AI-powered architecture decision tools, building semantic memory systems in Rust, and watching GitHub quietly position itself as the AI ecosystem to beat, I would have believed the first two but questioned the third. Yet here we are.

2025 was the year I stopped talking about AI developer tools and started building them. Here’s what shipped, what I learned, and where things are headed in 2026.

What I Built

zircote/git-adr: Architecture Decisions Without the Clutter

zircote/git-adr solves a problem that’s bothered me for years: Architecture Decision Records (ADRs) are valuable, but storing them as files in your repository creates noise. They clutter directory listings, complicate merges, and sit awkwardly between code and documentation.

The solution? Store ADRs in git notes. They’re versioned, tied to commits, but invisible to your normal workflow.

# Create an ADR
git adr new "Use PostgreSQL for persistence"

# AI-assisted drafting
git adr draft "We need to choose a message queue"

# Search past decisions
git adr search "database"

What makes zircote/git-adr interesting isn’t just the git notes storage—it’s the AI-powered drafting. Describe your decision context in natural language, and Claude generates a structured ADR with context, options, and rationale. No templates to remember, no format debates.

The CLI is Python, but the search capabilities rely on semantic understanding powered by vector embeddings. Fast, precise, and genuinely useful for finding “that decision we made six months ago about caching.”

Status: Active development. Homebrew formula available. VS Code extension in the works.

zircote/claude-spec: Project Planning That Works Well

zircote/claude-spec emerged from frustration with how projects start. Requirements gathering is usually either too formal (heavyweight documents nobody reads) or too informal (Slack threads that vanish). Neither works well with AI assistants.

claude-spec provides a structured workflow:

  1. Socratic Elicitation: AI asks questions to surface requirements you didn’t know you had
  2. PRD Generation: Conversations become Product Requirements Documents
  3. Architecture Planning: Technical specs with implementation details
  4. Progress Tracking: PROGRESS.md files that persist across sessions
  5. Worktree Management: Isolated git worktrees for parallel development

The workflow is simple:

/cs:p "Build a rate limiter for our API"  # Plan
/cs:i rate-limiter                        # Track implementation
/cs:s                                     # Status check
/cs:c rate-limiter                        # Complete and archive

What I learned: Good planning isn’t about more documentation—it’s about capturing the right context at the right granularity. zircote/claude-spec helps AI assistants remember what you decided and why, which turns out to be 90% of the battle.

Status: Active. Claude Code plugin available via marketplace.

zircote/subcog: Semantic Memory That Actually Remembers

This one I’m particularly excited about. zircote/subcog is a multi-domain, long-horizon memory system with progressive hydration and a prompt store, all delivered via CLI with hooks, transcript search, active memory recollection, and more.

Think of zircote/subcog as giving your AI assistant a working memory that persists across sessions and projects. It:

zircote/subcog supersedes the zircote/git-notes-memory experiment. Both achieved strong results in early trials:

Benchmark subcog no-memory Δ Improvement
LoCoMo 85% (27/50) 0% +85% ✓ MEMORY HELPS
LongMemEval 98% (49/50) 0% +98% ✓ MEMORY HELPS
ContextBench 68% (14/50) 0% +68% ✓ MEMORY HELPS

Python afforded a rapid prototype and validation; Rust brought performance and security once I had the architecture laid out and understood. This was also a real test of using spec-driven development to start in one language (Python) and apply the developed spec to a new language. It worked very well.

The key insight: Large context windows aren’t the same as good memory. You need semantic search, confidence scoring, and intelligent hydration. zircote/subcog provides all three.

Why Rust? Because performance matters for semantic search, and Rust makes it possible to build memory systems that are both fast and safe. Also, Rust is phenomenal. More on that below.

Status: Feedback and feature discussions welcomed.

The Supporting Cast

Beyond the major projects:

What I Learned

Rust Is Phenomenal (And I Mean It)

I resisted Rust for longer than I should have. The learning curve felt steep, the ownership model seemed pedantic, and “it compiles, it works” felt too good to be true.

It is true.

Once you internalize borrowing and lifetimes, Rust becomes the language you reach for when correctness and performance both matter. For subcog’s semantic search, Rust means:

But here’s what surprised me: Rust makes you a better programmer in other languages. Understanding ownership changes how you think about data flow everywhere.

The tooling is excellent (cargo is what package managers should be), the community is helpful, and the compile errors are genuinely instructive. If you’ve been on the fence, 2026 is the year to dive in.

GitHub’s AI Ecosystem Is a Sleeping Giant

There’s been a lot of talk about AI model providers—OpenAI, Anthropic, Google, etc. But the real competitive moat isn’t the model; it’s the ecosystem.

GitHub has quietly assembled an AI development platform that’s more approachable for non-technical organizations than GCP or even Google’s AI offerings:

These tools work for content generation, video production, back office productivity, project management, compliance and governance, SDLC, and training. Google has powerful offerings (Gemini, Vertex AI, etc.), but the adoption gap is real. GitHub’s ecosystem is where developers already work. No migration needed, no new workflows to learn.

At some point—probably sooner than we think—these pieces will converge into something formidable. GitHub isn’t just building AI tools; they’re building the infrastructure layer for AI-assisted development.

Well done, GitHub.

Open Source Momentum Is Real

Life had me away from public open work for a while, but I’m happy to be back and hope to have things worthy of sharing. Every tool I shipped in 2025 started as “something I needed for myself.” Releasing them publicly created unexpected momentum:

Open source isn’t altruism—it’s enlightened self-interest. Building in public makes you build better.

What’s Next in 2026

Near-Term (Q1)

Medium-Term (Q2-Q3)

Long-Term Vision

AI-assisted development is still in its awkward adolescent phase. The tools work, but the workflows are still being discovered. My focus for 2026:

  1. Memory and context: Tools that help AI assistants remember what matters
  2. Workflow integration: AI that fits into existing processes, not the reverse
  3. Developer experience: Making powerful tools accessible without complexity tax
  4. Agriculture tech: Bringing the same developer productivity mindset to farming. I’m really eager to help other farmers—technical and non-technical alike—become more adept, informed, and empowered to apply these rapidly emerging tools. On the farm I see a shortage of labor; can’t find help when you need it. While in one field people are worrying about the future, in another you can’t seem to find help. I appreciate being fortunate to have a foot in both worlds. One makes me appreciate and be better at the other.

The Unifying Theme

Whether it’s zircote/git-adr, zircote/claude-spec, or zircote/subcog, the pattern is the same: take something powerful but awkward and make it obvious.

Architecture decisions are valuable—store them where they belong (git notes). Project planning matters—capture it conversationally (zircote/claude-spec). AI assistants need memory—build it semantically (zircote/subcog).

2025 was about building these tools. 2026 is about making them indispensable.

Join In

If you’re building AI developer tools, exploring Rust, or working on agriculture tech, let’s connect:

What are you building in 2026? Reply with your projects—I’m always curious what people are working on.

This is the first in a series of posts about AI-assisted development workflows. Next up: “The State of AI Coding Assistants in 2026” comparing Claude Code, GitHub Copilot, Cursor, and emerging tools.