Crossposted from Prime Radiant's blog – I'm really excited about all of the stuff we are doing at Prime Radiant. For the most part we're blogging about it over there, but I'm going to continue to lift the occasional post m back to my personal blog.

Today, we're pleased to share the initial research previews of two new pieces of technology we've built at Prime Radiant:

  • Greenfield – our suite of tools for turning existing software into behavioral specifications.
  • Iterative Development – an agentic methodology for building bigger software products from detailed specifications without dropping requirements.

Both of these projects are brand new. We've used and tested them internally, but they are not yet hardened production-grade software. We're releasing them today to start to gather feedback on how well they work for your projects.

Greenfield and Iterative Development grew out of our work on Superpowers. Greenfield works as a standalone tool and Iterative Development depends on Superpowers for some of its magic. (Superpowers started life as my personal agentic development methodology. I'm the Founder and CEO of Prime Radiant. Superpowers is now a Prime Radiant project.)

We first designed Greenfield as an experiment in agentic "clean room" reverse engineering. It's built to tease apart a software product, starting from a codebase, documentation, API clients, and other collateral.

It turns all of that input into a corpus of behavioral specs for everything from public API contracts to user journeys. Just as importantly, it works hard to make sure that it doesn't include the product's internals in those specs.

While you can use Greenfield to explore any codebase, we're most excited about the possibilities it opens up for extracting design and intent from under-documented historical "brownfield" codebases, making it possible to build new, clean implementations.

Greenfield is incredibly token-hungry. Using it to generate specs from a non-trivial codebase with a Claude Max 20x subscription will almost certainly exhaust your five-hour window several times over. While we have some ideas for how to make it significantly more efficient, we're very focused on making its outputs as good as they can be and only then optimizing for token spend.

One sample project we tested Greenfield + Iterative Development against was Ghost Pepper, Matt Hartman's excellent local-first dictation app for MacOS.

We chose Ghost Pepper as an example because it's an open source app that I've been doing a significant amount of work on lately. It exercises enough UI complexity, OS framework integration, and third-party library usage to be non-trivial, but isn't so large that results are hard to evaluate. Also, because of how it was built, it had no significant design documentation.

Over the course of a few hours, Greenfield generated approximately 500k of human-readable textual specs. We've published a snapshot of those specs and the regenerated version of "Ghost Pepper 1.9.0" on GitHub. You should not use this version of Ghost Pepper. It's just there so you can see what the generated output looks like.

If you've spent any significant time using an agent to build software, you are likely aware of the pain that comes when you hand your agent a spec that's too big. It skips steps, misses features, and generally just fumbles the implementation. Even Superpowers tends to cap out at plans that are a small fraction of a Greenfield-generated specification.

To that end, we're open-sourcing the first version of 'Iterative Development', a new set of skills and tools designed to augment Superpowers so it can take big spec packages, parse out individual requirements into something a little bit like "user stories", bundle those into development epics that coding agents can wrap their heads around, and then execute the heck out of an implementation.

Iterative Development is very, very young, but our first experiences with it have been really promising. We've been testing it with both Claude Code and Codex and have been pretty happy with the early results. It builds working software from gigantic specs and has done a great job of not skipping requirements.

The most recent run of "rebuild Ghost Pepper 1.9.0" built a fully working implementation of the product with dramatically better test coverage than the original, which was great. Manually testing the Ghost Pepper reimplementation, however, was a little tricky because the auto-updater configuration was correct and the reimplementation kept trying to "update" itself to the latest release of the real Ghost Pepper! One thing that wasn't yet as good about the rebuilt Ghost Pepper was that it ended up with a more complex internal API surface to support that better test coverage. Right now, a lot of the tuning we're doing to Iterative Development is around improving its engineering taste and architecture.

If you try out Greenfield or Iterative Development, we'd love to hear from you. Drop us a line at hello@primeradiant.com.