AI-native delivery broke that partnership. Kettel rebuilds it — a shared plan where all three voices think together, and the agent ships the synthesis.
Every enterprise trying to scale AI-native delivery hits the same wall. The creative partnership that produces excellent work — the back-and-forth, the challenge, the yes, and — gets flattened into one person's conversation with an LLM. The rest of the team is a spectator. Intent gets lost. Craft gets diluted.
Someone defines what matters. Someone else interprets it into direction. A third translates both into prompts. By the time code ships, there are four layers of telephone game between what was wanted and what got built.
People who span strategy, creative, and technology are rare, burn out fast, and don't scale. Every AI coding tool on the market is built for that unicorn. Kettel is built for the team that replaces them.
A Kettel plan is a structured markdown file in your git repo. Each section has an owner. Each annotation has a perspective. The agent reads all of it — strategy's intent, creative's direction, technology's approach — and produces code that reflects the synthesis, not just the last prompt.
It's a handoff artifact: self-contained enough for Claude Code, Cursor, or Windsurf to read and execute without needing access to Kettel at all.
A new user can drop in any file and see it become a linked notebook entry within 10 seconds. No format coaching.
The conversion is visible — the user watches a PDF become paragraphs, an image become a described frame. Progress is narrative, not a bar.
Vercel edge functions per format, streamed to the client. Vision model for images. Markdown write-back to the repo is atomic.
Research, customer quotes, references, spikes, debates — atomic entries that link to each other and to the plan. The agent traverses the graph, not a pile.
R. — director of platform at mid-market SaaS. Signal: intent decay is the primary complaint.
What if the acceptance criteria is the test suite the agent runs?
Threads anchored to regions, not files. Context travels with the work.
If the plan is the contract, MCP is the socket. v0.2 target.
Section locking wins for MVP — CRDTs revisit when build mode ships.
The team gathers knowledge in the notebook. PDFs, URLs, screenshots, Slack threads — auto-converted to linked markdown.
Strategy writes intent. Creative writes direction. Technology writes approach. Section locking. Inline annotations. Every voice has attribution.
The agent reads the full plan and linked notebook entries. Generates implementation steps that respect constraints from all three perspectives.
Self-contained plan handed to any coding agent — Claude Code, Cursor, Windsurf. The plan is the interface contract. No lock-in.
Category forming. Aviator coined "multiplayer AI coding." YC S26 RFS names the "deciding what to build" gap explicitly.
Spec-driven validated. GitHub Spec Kit, Amazon Kiro, Thoughtworks Radar — the industry is converging on plans-before-code.
Incumbents locked in. GitHub defaults to issues. Cursor to the IDE. Augment to engineers only. None are plan-native.
The shared artifact. The plan is the viral loop. Every person who receives a link becomes a user. Distribution is built into the format.
Illustrator had better brushes. Sketch had better pixel precision. Figma had a shared URL. Designers stopped exporting PNGs to Slack because the artifact lived where the conversation lived. The medium ate the incumbents.
The same shape is forming now. The best single-player AI coding tools already exist. What doesn't exist is the shared canvas — the place where strategy, creative, and technology meet before code is written. Kettel is that canvas.
Having 8 agents write code all day generates more code in a day than one person can review in a week.— Hacker News, 2026
An effective spec-driven-development tool would have to provide a very good spec review experience.— Martin Fowler, 2026
What's missing is how to share all that context. I don't think any one current solution will be the winner.— HN, on team collaboration with coding agents
The intent behind decisions gets lost. You're left with a codebase nobody fully understands anymore.— Red Hat Developer, "The Uncomfortable Truth"
Plan file, notebook, section locking, annotations, agent discovery + plan modes, GitHub integration, ingestion pipeline.
SSO, audit trails, access controls, hosted version, compliance, advanced analytics, priority support.
Craft doesn't scale through faster execution. It scales through better thinking. The more powerful the agent, the more the plan matters — and Kettel owns the plan.