Transform your engineering workflow from linear to exponential through compounding AI automation.
A Claude Code plugin marketplace featuring specialized AI agents and workflows customized for modern distributed systems: Go, Java/Spring Boot, C/C++, React/TypeScript, Apache Cassandra, PostgreSQL, Apache Kafka, and OpenSearch.
AI Stack Engineering brings the Compounding Engineering Philosophy to your development workflow. Each unit of work doesn't just complete a task—it teaches the system, making every subsequent task easier, faster, and higher quality.
This isn't just another AI coding assistant. It's a fundamental shift in how we build software:
- Linear AI: Helps with today's problem, starts fresh tomorrow
- Compounding AI: Learns from every interaction, applies patterns automatically, prevents entire categories of bugs
At Digitalis.io, we work with complex distributed systems daily. While AI assistants help with individual tasks, we needed something that:
- Learns from our specific tech stack patterns
- Prevents the bugs we've seen in production
- Scales our engineering expertise across the team
- Compounds knowledge over time, not just solves today's problem
This project customizes the brilliant compounding engineering framework by Every, Inc. for our specific technology stack.
This project is based on every-marketplace by Every, Inc.
We are deeply grateful to Kieran Klaassen and the team at Every for creating the Compounding Engineering Philosophy and the original plugin framework. Their innovative vision of AI-powered development workflows inspired us to create this specialized version.
Our contribution focuses on adapting their framework for distributed systems engineering with our specific tech stack while maintaining the core philosophy that makes it powerful.
# 1. Add marketplace directly from GitHub
claude /plugin marketplace add https://github.com/digitalis-io/ai-stack-engineering
# 2. Install the plugin
claude /plugin install ai-stack-engineering
# 3. (Recommended) Install Context7 for up-to-date docs
claude mcp add --transport sse context7 https://mcp.context7.com/sse# 1. Clone the repository
git clone https://github.com/digitalis-io/ai-stack-engineering
# 2. Add marketplace from local path
claude /plugin marketplace add ./ai-stack-engineering
# 3. Install the plugin
claude /plugin install ai-stack-engineering
# 4. (Recommended) Install Context7 for up-to-date docs
claude mcp add --transport sse context7 https://mcp.context7.com/sse/plugin list # Should show ai-stack-engineering
/mcp list # Should show Context7 (if installed)
/review # Test the review command# Plan a feature with AI research
claude /plan "Build Kafka consumer that writes to Cassandra"
# Execute the plan
claude /work
# Review with specialized agents
claude /review
# The magic: Next time you build something similar,
# the system already knows your patterns┌─────────────────────────────────────────────────────────────────────┐
│ │
│ 📊 TIME TO BUILD SIMILAR FEATURES │
│ │
│ Week 1: ████████████████████████████████████ 4 hours │
│ Week 2: ████████████████████ 2 hours │
│ Week 4: ████████ 1 hour │
│ Month 2: ██ 20 minutes │
│ │
│ 🚀 10x FASTER with better quality │
│ │
└─────────────────────────────────────────────────────────────────────┘
PLAN DELEGATE ASSESS CODIFY
🎯 ➜ 📋 ➜ 🔍 ➜ 📝
Research AI Builds Review Code Save Learning
┃ ┃ ┃ ┃
└────────────────┴───────────────┴───────────────┘
⬇
Knowledge compounds
for next iteration
1. 🎯 PLAN - AI researches best practices for your exact stack
- Searches Cassandra docs for partition strategies
- Finds Go concurrency patterns that work
- Learns Kafka delivery guarantees
2. 📋 DELEGATE - AI builds with accumulated knowledge
- Applies your code style automatically
- Uses patterns that worked before
- Avoids mistakes from previous iterations
3. 🔍 ASSESS - 23 specialized agents review in parallel
cassandra-guardianprevents hot partitionskafka-guardianensures no data lossgolang-reviewercatches race conditions
4. 📝 CODIFY - Learnings become permanent rules
- "Always use prepared statements with Cassandra"
- "Never use unbuffered channels in Go"
- "Always commit Kafka offsets after processing"
Week 1: 4 hours to build a feature (learning your patterns) Week 2: 2 hours for similar complexity (applying patterns) Month 2: 40 minutes for the same work (full compound effect)
The system learns:
- ✅ Your code style and conventions
- ✅ Your common bugs and how to prevent them
- ✅ Your architecture patterns
- ✅ Your tech stack quirks (Cassandra partitions, Kafka offsets, Go concurrency)
The Result: Not just faster development, but exponentially better code quality.
"I've debugged production at 3am. Make it obvious, make it work, make it fast—in that order."
- Catches concurrency bugs, goroutine leaks, race conditions
- Enforces idiomatic Go patterns (Uber style guide)
- Production-ready error handling and observability
"I've seen AbstractSingletonProxyFactoryBean and lived. Keep it simple."
- Prevents overengineering and enterprise anti-patterns
- Spring Boot configuration and best practices
- SOLID principles without the religion
"Ah, another hot partition in the making. Let me save you from 3am alerts."
- Modern features: SAI indexes, vector search, UCS compaction
- Prevents unbounded partitions and tombstone disasters
- Data modeling that actually scales
"At-least-once usually means at-least-twice. Let's fix that."
- Ensures delivery guarantees actually work
- Prevents data loss during rebalancing
- Consumer group management that survives production
"Every unnecessary re-render is death by a thousand paper cuts."
- Catches hook dependency issues before they bite
- Prevents infinite re-render loops
- TypeScript that actually helps
"Your fancy query DSL doesn't matter if users can't find anything."
- OpenSearch/Elasticsearch relevance tuning
- Query performance at scale
- Index design that doesn't explode
"Make it correct, make it safe, then make it fast. In that order."
- Memory safety and RAII enforcement
- Catches undefined behavior before it crashes production
- Thread safety and race condition detection
- Cassandra C++ driver expertise
A comprehensive suite of specialized agents for every aspect of software development:
- Code Quality - Simplicity, security, and performance optimization
- Architecture - System design and pattern recognition
- Data Systems - Database integrity and PostgreSQL optimization
- Research - Documentation and best practices discovery
- Workflow - PR resolution and knowledge capture
- Language Experts - Rails, Python, and TypeScript specialists
📖 See Complete Agent Guide - Detailed documentation for all 24 agents with personalities, expertise, and use cases.
- 📖 Workflow Guide - Comprehensive guide to compounding engineering
- 🚀 Quick Start - Get running in 5 minutes
- 📝 Article: The Philosophy - Original concept by Every
| Command | Purpose | What It Does |
|---|---|---|
/plan |
Strategic planning | Researches best practices, creates implementation phases |
/work |
Execute tasks | Implements with learned patterns applied |
/review |
Multi-agent review | Parallel analysis by all specialized agents |
/triage |
Issue prioritization | Decides what to fix and in what order |
/resolve |
Parallel fixes | Resolves multiple issues simultaneously |
/context |
Memory management | Monitors token usage and suggests compaction |
Fix bug → Done
Write feature → Done
Review code → Done
Fix bug → Test added → Pattern recorded → Category prevented
Write feature → Pattern learned → Reused automatically
Review code → Standards extracted → Applied forever
Every bug becomes impossible to repeat. Every review makes future code better. Every feature becomes a reusable pattern.
Digitalis.io specializes in:
- Cassandra Consulting: From modeling to operations at scale
- Kafka Architecture: Event-driven systems that don't lose data
- Distributed Systems: Building systems that scale
- Performance Engineering: Optimizing for real-world workloads
We've taken these production learnings and encoded them into our AI agents.
While this is a customized fork for our tech stack, we welcome:
- Bug Reports: Found an issue? Open an issue
- Stack Adaptations: Want to fork for your stack? We'll help!
- Agent Improvements: Better patterns for our tech? PR welcome!
For the original framework or different tech stacks, visit every-marketplace.
- Every Marketplace - The original framework
- Apache Cassandra - The database that scales
- Apache Kafka - Event streaming platform
- OpenSearch - Search and analytics engine
MIT License - See LICENSE file for details.
Based on every-marketplace by Every, Inc., used under MIT License.
Ready to compound your engineering?
⭐ Star this repo • 🐛 Report an issue • 💬 Join the discussion
Built with ❤️ by Digitalis.io • Inspired by Every