Founding AI Researcher
Full-time | On-site | London, UK
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.
The proto-language of prompts that’s emerging right now is at the “spaghetti prompts” stage:
- important decisions are largely buried in session logs that nobody reads (because they are often not very readable),
- exploration, ideation, and prototyping are mixed with careful construction of lasting architectures,
- there’s no modularity, abstraction, or static checks on prompts.
To fix this, we need to do the same things we did to fix spaghetti code: we need to organise the high-level intent from prompts into always-up-to-date, reusable logical modules that humans and agents can navigate. Like modules in a programming language, but on the next level. That’s Software Engineering for the age of AI, and CodeSpeak is building tools that make it possible.
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.
Solving this problem requires a unique blend of engineering and ML. So we're now building the second half of the team, to take on the challenges we can't solve without strong ML peers.
We hire very fast, just two tech interview stages + final. We work in person and are ready to relocate you to London.
💡 We'd love to see more women apply. If you're on the fence, please do apply, and if you know someone brilliant (whether they are actively looking or not) please share!
28% of computing graduates in the UK are women. It's a lot of talent we don't want to miss out on.
Challenges
Representation learning for developers' intent
What is the right representation of what developers want to build (developers' intent)?
Design representations that enable AI systems to reason about software at the level of intent rather than code. These representations must be understandable by humans, navigable by AI coding agents, grounded in implementation, and robust as systems evolve. They should support retrieval, compositional reasoning, verification, modularization, and efficient long-term maintenance.
Intent understanding & requirement synthesis
How can the developer's intent be faithfully inferred from transcripts of coding agent sessions?
Infer the intent from long, noisy conversations between developers and coding agents, and synthesize a faithful representation of requirements, constraints, and design decisions. Rather than summarizing the conversation, the challenge is to recover the incremental changes in developer intent, grounding every synthesized requirement in the original user requests while preserving their level of abstraction and uncertainty. The system should resolve ambiguity and identify reusable concepts, but avoid hallucinating details or assumptions that were never expressed.
Requirement-to-code grounding
Where and how is this intent realized in the codebase?
Maintain mapping between the developer's intent and implementation artifacts. The mapping must remain accurate despite refactoring, agent-generated code changes, architectural evolution, and implementation rewrites, requiring joint reasoning over requirements, source code, execution artifacts, and development history.
Intent evolution (override vs. regression)
Did the intent evolve, or did the implementation accidentally drift?
Reason about how the developer's intent and the implementation co-evolve over time. Given new user requests, code changes, and development history, determine whether changes in system behavior reflect an intentional evolution of user requirements or an unintended implementation drift. This requires jointly reasoning over user requests, source code, execution artifacts, and development history to distinguish intended changes in behavior from unintended semantic drift.
Global requirement consistency
How can AI maintain a globally consistent model of developers' intent?
Maintain a globally coherent model of developers' intent by detecting contradictions, hidden dependencies, overlapping concepts, and incompatible assumptions across requirements introduced by different developers and AI coding agents across months or years of development. Assist users in resolving conflicts while preserving the intended system behavior.
Evaluation of AI coding agents
How should coding agents be evaluated beyond simple execution-based proxies?
Evaluating coding agents remains an open research problem. Existing benchmarks often rely on execution-based proxies such as passing tests or producing syntactically correct code, but these metrics say little about whether the agent correctly captured and implemented the user’s intent. We develop new evaluation methodologies spanning developer-agent conversations, evolving requirements, code changes, execution artifacts, and long-running development workflows. This includes designing datasets, metrics, and evaluation protocols that measure intent faithfulness, grounding quality, semantic correctness, and long-term maintainability rather than superficial implementation success.
Ideal candidates
Smart, curious, self-driven applied researchers who believe in our mission.
Green flags include hands-on experience with:
- Solid foundation from classic ML to modern neural networks,
- Expertise in LLMs: serving, fine-tuning (SFT, LoRA), quality evaluation, and designing custom benchmarks,
- Experience designing and evaluating agentic/multi-agent systems from 0 to 1,
- Strong skills in inference optimization and agentic workflow tuning: quantization, batching, KV-cache, context engineering, and overall reducing latency and cost.