Speed is not your problem anymore. AI handles code generation fast enough that the real fight now is keeping your architecture from quietly falling apart while the agent writes feature number seven. Most teams don’t even notice the drift until they’re staring at a codebase that runs but doesn’t make sense anymore. Modules are coupled when they shouldn’t be. Naming conventions started clean and got inconsistent by feature three. The agent kept building on whatever context it had in the moment, and nobody was watching the bigger picture while it worked.
That’s the gap. Fast output with no structural memory.
A CTO named Abdo figured this out the hard way. So he built Apex Feature Kit, a VS Code extension now in beta on the Marketplace, designed to turn “vibe coding” into a proper engineering system built around Feature-Driven Development. FDD isn’t new. It’s a structured methodology where you define your features explicitly before touching a line of implementation, break work into small deliverable chunks, and keep a running model of how everything connects. The idea is that you never let the codebase outpace your understanding of it. What’s new is applying that discipline specifically to AI-assisted builds, where the agent’s context window is the biggest risk to architectural coherence.
The twist: it doesn’t just hand you a spec document at the start and hope the agent remembers it ten features later. It visualizes your architecture evolving in real time, right inside VS Code, as the agent builds. You’re not reading a static diagram you made on day one. You’re watching a live flowchart update as each feature lands, showing you how components connect and where new dependencies appear. The moment something looks off, you see it at the feature level, not three weeks later during a refactor.
That’s the part that’s actually new. The community in the thread spotted it instantly: spec kits solve the upfront problem. Nobody solves the drift problem. This one tries to. The thread had engineers describing their current setup, usually some combination of a detailed README, a CLAUDE.md or AGENTS.md file, and a lot of hoping the context held. Those approaches work for the first few features. They break down around feature eight when the agent starts making locally reasonable decisions that are globally inconsistent with what came before. Apex Feature Kit is attempting to close that gap with a feedback loop that stays active through the entire build, not just at kickoff.
How to get it running:
- 🗂️ Install Apex Feature Kit from the VS Code Marketplace (search the name directly). The install is standard. No extra config files outside of VS Code, no CLI dependencies you need to track down separately.
- 📋 Define your feature specs before the agent touches a single file. This is the discipline the whole system depends on. Write each feature as a concrete, bounded unit. If you can’t describe the feature without saying “and also,” it’s two features. The specs become the structural anchor the Visualizer references as the build progresses.
- 🔄 Start building while the Visualizer tracks architectural progress in real time. This is where the extension does its actual work. You’ll see the flowchart populate as features complete, showing component relationships and flagging when something new connects to something it probably shouldn’t. Treat the Visualizer as a second reviewer, not just a status board.
- 📊 Watch the flowchart update feature by feature and catch drift before it compounds. The compounding is the real danger. One inconsistent dependency in feature two becomes load-bearing by feature six. Catching it at feature two costs you maybe an hour. Catching it at feature six costs you a day and a rewrite you didn’t plan for.
Pro tip: If you’re already using GitHub Spec Kit and hitting friction, this positions itself as the lighter, faster alternative. Worth running a small feature side by side to compare how much structure it actually enforces mid-build, not just at kickoff. Pay specific attention to how each tool handles the moment you deviate from the spec. That’s the real stress test. GitHub Spec Kit will tell you what you planned. Apex Feature Kit is claiming it will show you what actually happened and whether those two things still match. That’s a meaningfully different product. If it delivers on that promise, it fills a gap that’s been open in the AI-assisted development space since agents got fast enough to outrun human review. Run the comparison on something real but low-stakes, then decide.
🚀 Grab the beta on the VS Code Marketplace and send the builder your technical feedback.
Frequently Asked Questions
Q: How is Apex actually different from SpecKit?
Good question, SpecKit gives you solid upfront specs, but it doesn’t catch what happens next. The real issue? Once AI agents start implementing, they drift away from those specs without anything actively watching. Apex tackles this with a live visualizer in VS Code that shows your architecture in real-time, so you can see when things start drifting before they become a mess.
Q: Why is keeping your architecture together so hard when AI is writing code?
AI is blazingly fast at writing code, but here’s the catch: each time an agent works on your repo, it builds its own mental model. Without something persistent showing the actual architecture, agents in different sessions end up understanding your codebase differently. That invisible state drift is what tanks maintainability.
Q: How does watching architecture in real-time actually help?
Instead of just documenting what should exist (like traditional specs), the visualizer shows what actually exists in real-time through flowcharts and task lists. This shared, visible picture grounds agents across sessions, they all see the same architectural truth, making it way harder for drift to creep in.
Q: How does it enforce guardrails, is it all prompt rules, or does it actually validate things?
The post doesn’t spell this out, so it’s definitely worth asking the creator directly. Some tools rely on prompts alone, while others layer in actual validation gates (schema checks, file constraints, test gates) before agents can proceed. Find out which approach Apex takes.
Q: When does this level of structure actually become worth the effort?
According to folks in the comments, once your project gets past the “proof of concept” phase, architectural coherence becomes the real bottleneck, not code generation speed. That’s when tools focused on visibility and structure (rather than pure speed) really start earning their keep.
I built a VS Code extension that generates live architecture flowcharts to keep AI coding agents on track.
by u/ABDO_AR in PromptEngineering