About us
We got into software because we liked making things, but we found the reality of professional software engineering to be disappointing:
spending days on simple features because we needed to cut across legacy code
having meetings to find out if a change is safe
multi-week projects to unwind a technical decision someone made years ago
AI is making it easier to generate code, but it’s making technical debt more severe. The velocity of code changes is overwhelming our ability to keep our codebases sane.
Nocturnal Software Engineering
We love agentic software engineering. We make extensive use of Cursor, Claude Code, Amp, and Zed. We can do in an hour what used to take a week.
We think the next step is a “nocturnal phase” for software engineering. We should be able to write code all day, blazing through new ideas, and sophisticated agents should run overnight to clean up the mistakes and messes we leave behind.
To unlock a nocturnal phase for software, we started with writing tests. We built an agent that can write thousands of new tests for a typical codebase, all merge-quality. Our customers merged hundreds of PRs generated this way. Our thinking was: if you can test well enough, you can automate a lot of other software engineering work at very high quality. This is especially true if you're trying to change how software is implemented without changing its behavior – i.e. most work to resolve tech debt.
Finding Bugs
Along the way we realized two things: 1) while we had set out to write good tests, we had almost accidentally built an agent that was very good at finding bugs, and 2) almost every codebase has tons of bugs lurking in it, which are very easy to fix once you identify them.
Today, our product is a bug-finder that performs “deep scans” of your codebase. Detail exercises your code in thousands of different ways and reports the issues we find that are most worthy of your attention. We’ll introduce additional functionality later to solve as much of the technical debt problem as we can. But before we automate the codebase investments that prevent new bugs, we should fix the obvious bugs that are already there.
Compute is cheap, human attention is expensive
Code is cheap now. Wielded properly, the newest models can execute complicated changes, even in large codebases. That means the limiting reagent in building software is human attention. It still takes time and focus for an engineer to ingest information, e.g. existing code, organizational context, and product requirements. These are all necessary before an engineer can articulate what they want in precise terms and do a good job reviewing the resulting diff. [1]
Our approach trades compute for quality. Our codebase scans take hours, not minutes – far beyond what would be practical for a code review bot. But the result is that we can make more judicious use of engineers’ attention, and that’s going to be the most important variable.
If nocturnal software engineering can be a little more proactive, it can be a lot more powerful. But that’s only going to work if we can make very good decisions about what’s worth a human’s attention. Nobody wants to inherit a mess from an overactive night shift.
We’re Hiring
We would love to get to know you, especially if:
You like speed, and you're excited about the prospect of being on a small, high-performing team. You're comfortable making pragmatic choices with imperfect information and learning from contact with reality.
You want to build a company from the ground up. We intend for anyone we hire at this stage to play a major role in shaping everything we do: the product, the team we build, and the company's direction.
You're not afraid of reading a lot of code. Building this product requires a lot of schlepping. We need to manually, subjectively review a lot of bug reports to find the problems with our product and evaluate improvements. We read a lot of code and make a lot of spreadsheets. It's the only way. (But it is working!).
You're opinionated about devtools. You have favorite tools. You're the person who teaches your teammates about better ways to do things
We're backed by top-tier angels: Guillermo Rauch, Olivier Pomel, Christina Cacioppo, Arash Ferdowsi, Alex Graveley, Barry McCardel, Dev Ittycheria, Guy Podjarny, Zach Lloyd, and many other outstanding people.
[1] The most effective engineers are experts at allocating this scarce resource. They have a nose for which parts of a diff need careful review or what aspects of a prompt are worth articulating carefully. They can sniff out opportunities to spend $6 in tokens to build themselves a oneoff tool that saves 45 minutes.