About CodeSpeak

CodeSpeak is an Agentic Engineering Toolkit: a set of tools to make AI coding work well for production-grade software projects.

Coding agents are amazing for prototypes, one-offs, and hobby projects. Yet, for serious production, results are more mixed:

• the amount of slop in codebases is growing, and they become less and less maintainable (GitClear-26),
• people can’t keep up with reviews,
• and more and more areas in projects accumulate “comprehension debt” (nobody really understands how they work).

As a result, engineering leaders are seeing more incidents per PR (+23.5%, see Cortex-26). In other words, people ship slop, and it’s starting to bite them. “The Claude Code moment” happened in late 2025, so what we see today is not even the full extent of the consequences.

At CodeSpeak, we believe three simple things:

• AI coding tools can help people make quality production software;
• Nobody wants to ship slop, people just don’t have the right tools to remain on top of their codebases;
• While coding may be solved by models, Software Engineering is still a human job.

CodeSpeak’s Vision. The prompts we give to coding agents are a new proto-language that is emerging right now. And we want to make it into a good, usable production language. The valuable part is that these prompts contain the intent behind the code. The resulting code can be generated from it, therefore it must be a complete description of the system. Right now, this description is very messy, and we want to make it clean and useful.

CodeSpeak’s Current Approach. We believe that user intent is the real primary artifact, and code is just what's derived from it. Right now, we're building an engine that captures this intent from session transcripts, distills it into structured requirements, grounds them in the code, and enforces them as the codebase changes.

These requirements become the layer developers actually work through, across the entire development process. For example:

• When an agent starts a new feature, CodeSpeak injects the relevant requirements into its context, so it builds with the rest of the system in mind.
• When a new prompt in a chat contradicts older requirements, a code isn’t written until the conflict is resolved.
• Code review starts from the requirement-level diff: what intent changed, what constraints were added or removed, and whether the implementation still satisfies them.

See more in our blog, and this is only the beginning. Let’s talk about what will come next when we meet.

Team

CodeSpeak is founded by Andrey Breslav, creator of Kotlin – a language used by millions of developers every day. Around him is a team that has built the tools other engineers rely on, at Google, Databricks, Perplexity, JetBrains, Sourcegraph, and Elastic. When it comes to program analysis and developer tooling, these are some of the best people in the world.

The role

We are looking for a Founding Design Engineer to own everything about how people interact with CodeSpeak: in the CLI, on the web, and on whatever platform comes next. That means doing a crazy amount of prototypes, working out the right UX, and then shipping it with strong attention to detail and the same care for performance and product quality as for the design.

We're looking for someone who has strong visual taste, product thinking, and solid engineering skills. We're especially interested if you’ve found clever ways to present large amounts of complex information through a friendly UI, or built professional tooling that helps people to operate over complex concepts.

You will work directly with the founder and engineering team to take early ideas and hypotheses and turn them into intuitive, interactive product experiences.

What you'll work on

CodeSpeak deals with unusually complex information: developer intent, requirements, code, architecture, relationships between different concepts, changes over time, contradictions and dependencies.

The challenge is not simply to display this information, but to help developers understand it, navigate it and act on it.

You might work on interfaces that allow developers to:

• understand the high-level architecture of their project;
• navigate structured requirements and their relationships;
• review requirements together with reviewing code;
• understand how requirements map to different parts of a codebase;
• explore changes in developer intent, architecture, and code, over time;
• browse agent sessions;
• identify contradictions or inconsistencies between requirements;
• edit and reorganise requirements rather than simply view them.

Ideal candidates

• Smart, curious, self-driven engineers with a passion for making programming better.
• Have a solid understanding of CS/SE fundamentals and TypeScript.
• Deep experience building production apps with any modern UI frameworks such as React.
• Strong design taste, with a solid understanding of UX and interaction design principles, information architecture, and visual hierarchy.
• Have experience delivering production software: 3+ years.
• Actively improve their workflows with AI-powered coding tools.

---

---

References

• Cortex-26: https://www.cortex.io/post/ai-is-making-engineering-faster-but-not-better-state-of-ai-benchmark-2026
• GitClear-26: https://www.gitclear.com/write_only_mode_ai_research