0. Hero
Spec-Driven Development AI
Most "AI specification writers" work the same way: structured form, a few questions, polished document. That's not spec-driven development. That's a questionnaire with formatting.
The problem isn't the output — it's what's missing going in. Generic AI spec tools don't know your codebase. They don't know you're on Passport.js with session-based auth. They don't know your API layer is a tangle of legacy routes nobody wants to touch. They don't know which parts of your data model crack under load.
Tekk reads your actual codebase first. Then it asks the questions only a senior engineer would ask — grounded in what it found. The spec it generates isn't a starting point. Your coding agent executes it directly.
1. How Tekk.coach Does Spec-Driven Development with AI
This is what automated spec generation looks like when codebase awareness is the starting point — not templates.
Stage 1: Codebase reading
Before Tekk asks a single question, it reads your repository. Semantic search via embeddings for code discovery. File and regex search for precise lookups. Directory browsing for structural understanding. Full repo profiling — languages, frameworks, services, packages, dependencies. Works with GitHub, GitLab, and Bitbucket.
By the time the spec conversation starts, Tekk already understands your architecture. You're not explaining your codebase to a blank slate.
Stage 2: Informed questions
Tekk asks 3 to 6 questions. Not generic clarification questions — questions grounded in what it found. If your auth layer uses Passport.js with session-based flows, the question is about that specific implementation, not "how does authentication work in your app?" The questions surface real complexity: dependencies you haven't thought about, edge cases your existing patterns create, scope decisions that will matter later.
Stage 3: Architectural options
Where the decision isn't obvious, Tekk presents 2 to 3 architecturally distinct approaches with real tradeoffs. Not "Option A (recommended)" and two strawmen. Actual options with actual costs — what breaks, what you give up, what gets harder later. When there's a clear path, Tekk skips this and keeps moving.
Stage 4: Complete spec
The plan streams in real-time into the task editor (BlockNote) as the actual working document — not a chat message. Every spec includes:
- TL;DR — what you're building and why, in two sentences
- Building / Not Building — explicit scope boundaries. You know exactly what's in and what's out before anyone writes a line of code.
- Subtasks — end-to-end behavioral slices, each with acceptance criteria, file references, and dependencies
- Assumptions — with risk levels and consequences if wrong
- Validation scenarios — concrete end-to-end tests
That's what spec-driven development with AI looks like when the AI actually knows your code.
2. Key Benefits
Codebase-grounded specs, not template output Every question Tekk asks and every spec it generates references your actual files, patterns, and dependencies. The output reflects your architecture, not a generic best practice that may or may not apply to your codebase.
Questions that surface real complexity Vague specs produce vague code. Tekk's questions are designed to eliminate the ambiguity that causes rework — the kind of complexity that only becomes visible once you've read the code. Generic AI spec tools can't ask these questions because they've never seen your repo.
Architectural options with honest tradeoffs You make better decisions when you understand the tradeoffs. Tekk presents architecturally distinct approaches with explicit costs — not a recommendation with two token alternatives. You choose with full information.
Specs your coding agents can execute immediately The output is structured for Cursor, Claude Code, and Codex — acceptance criteria, file references, scope boundaries, validation scenarios. Your agents don't have to interpret or fill in gaps. They execute.
3. How It Works
- Connect your repo — GitHub, GitLab, or Bitbucket. Tekk profiles the codebase: languages, frameworks, services, packages.
- Describe the feature — One sentence or ten. Tekk takes it from there.
- Answer 3 to 6 questions — Grounded in what Tekk found in your code. No generic clarifications.
- Review options (if needed) — Tekk presents architecturally distinct approaches with tradeoffs. Pick the one that fits.
- Get the spec — Complete, structured, immediately executable. Streamed in real-time into your task editor as a living document.
- Execute with your agent — Hand the spec to Cursor, Claude Code, or Codex. They have everything they need.
4. Who This Is For
Developers building with Cursor, Claude Code, or Codex You know these agents need better input. You've seen what happens when they get a paragraph instead of a spec — the wrong file gets touched, scope creeps, you end up fixing what the agent broke. Tekk is the planning layer that makes your agents effective. These are the spec-driven development AI agents your workflow has been missing.
Product managers who need technically grounded specs Not template-based PRDs. Specs that reflect the actual codebase, the actual dependencies, the actual constraints. Tekk is the AI specification writer that understands the technical context — you get specs that engineering can actually use.
Solo founders and small teams You're shipping fast, touching domains outside your expertise, managing the product in your head while trying to keep the codebase coherent. Tekk gives you the senior engineering judgment you don't have time to hire — grounded in your specific codebase, for every feature you ship.
5. What Is Spec-Driven Development with AI?
Spec-driven development means making the spec the primary artifact — not the code. The spec defines scope, tasks, acceptance criteria, and file targets. Coding agents consume it and execute. The spec is the source of truth for you and for the agents doing the work.
Before SDD became a named practice, most developers using AI coding agents were doing the opposite: writing a rough prompt, letting the agent interpret it, fixing what came back. That works for trivial changes. For anything architectural — auth flows, data modeling, payments, integrations — the ambiguity compounds. The agent guesses. Some guesses are wrong. Rework follows.
SDD makes spec quality the engineering discipline. Write a precise spec first. Give your coding agent a blueprint it can execute without guessing.
How AI changes spec-driven development
Writing a good spec used to require deep domain knowledge and hours of work. AI can accelerate that — but only if it has the right context. That's where most spec-driven development AI tools fall short.
GitHub Spec Kit and OpenSpec give you structure and workflow. They don't read your codebase before generating anything. You supply the architectural context manually. Kiro (AWS) is genuinely codebase-aware and builds SDD directly into its IDE — but you can't bring Cursor or Claude Code. You're locked to Kiro's editor and AWS ecosystem.
Generic AI specification writers are further back. They're questionnaire tools with AI formatting. They produce documents. Not executable specs.
Why codebase awareness is the differentiator
The quality gap in AI spec generation comes down to one question: does the tool know your code before it writes the spec?
When Tekk asks whether to add magic link auth, it already knows your existing auth setup — the framework, the session model, the middleware, the affected routes. The question is precise because the context is precise. The spec references those actual files, flags the actual risks, and writes acceptance criteria against your actual architecture.
Without that context, the spec is a guess with good formatting. Your coding agent still flails.