Today we're launching Nuanced, a spec-driven development workspace for agentic coding.
We believe that writing well was always the most important skill in software engineering. Now it’s the only skill.
With code generation fast and cheap, the hard problem is staying precise about what you are actually building. Intent gets spread across chats, plans, markdown files, and tool outputs leaving behind a trail of temporary artifacts that add noise.
While producing code is effortless, it is easier than ever to lose the thread on system architecture and product direction. As the codebase grows exponentially, clarity doesn't come for free. You have to actively protect it.
Protect clarity at all costs
What’s missing is a way to clarify intent early and keep execution aligned as the product evolves. Without that, faster generation turns unclear thinking into constant interruption.
Nuanced is built to support a different mode of working. It keeps you a layer above the code so you can shape the system while agents handle execution. Instead of constantly reviewing generated diffs, undoing hidden assumptions, or reverse-engineering why something was built a certain way, you stay oriented around your own intent. You can refine the design and keep decisions coherent as the codebase grows.
Nuanced is a spec-driven workspace
Nuanced gives you a place to define what you’re building before and alongside execution. You start with a rough idea, turn it into a spec through progressive clarification, and generate tasks that stay grounded in that spec.
Instead of reacting to agent output, you shape the system directly. The spec remains the source of truth as the codebase evolves, keeping decisions aligned and traceable. This lets agents take on the mechanical work, while protecting the space you need to reason deliberately about product design and system architecture.
Why writing matters
My conviction about writing things down comes directly from my own experience. During my seven years at GitHub, the real work often started before any code was written. We would write documents to align on what we were building, but more importantly, the act of writing clarified my own thinking.
Writing forced me to be very precise. It helped me understand the problem, separate concerns, and make trade-offs explicit. Many times I only became fully aware of problems once I tried to explain them clearly.
That discipline mattered because systems I was working on were large and tightly coupled. At the time, GitHub was serving more than 100 million users, and even small changes could have wide-reaching effects. At scale, you had to reason carefully about how a given change could ripple through a system. You couldn’t just jump into coding and hope a design would emerge.
Writing created space for that kind of reasoning. Once something was written, teammates could easily challenge ideas or surface blindspots. This helped teams converge on a plan before misunderstandings hardened into architecture and became harder to fix.
This process worked well, but it was slow. Feedback cycles took days. Today, agents can compress that loop dramatically. You can pressure-test decisions in minutes, explore multiple directions with throwaway prototypes, and iterate on the spec while execution happens alongside it.
The missing layer isn’t more automation. It’s a place to think.
The opportunity now is to evolve specs to a new way of working. Specs can now be a living document of a system and be used to re-architect the system from whole cloth.
- Agents got better at execution. Over the past year, a few things changed at the same time. Context retrieval improved, agents learned to operate over much larger codebases, and parallel execution became common. As a result, attention shifted from perfecting the context toward orchestrating fleets of agents and keeping them running.
- Orchestration isn’t the hard part. Orchestrating agents isn’t the interesting problem, that’s largely a scheduling and tooling concern.The real work of software engineering is clarifying what to build, and creating space to progressively disambiguate intent.
- Execution is cheap, articulation isn’t. When code is easy to produce, ambiguity gets encoded directly into the system. Agents will happily fill in gaps with assumptions unless you make intent explicit.
- Ambiguity slows you down. Without upfront clarity, agents expand a system’s surface area before the product is defined. A vague prompt like “make this scalable” turns into a blizzard of half baked code before you’ve decided what’s actually needed. You end up inheriting complexity that is hard to unwind.
- We still lack a clean link between idea and code. Today’s tools push you to extremes. Either you are buried in agent outputs and diffs, or you are abstracted away from the system entirely. What’s missing is a layer that keeps intent, design, and execution connected. Right now, when an agent implements something, you see what has changed but not why. Come back a day later and you have to reconstruct intent from a mix of prompts, logs, and code.
How Nuanced works
Nuanced follows a simple workflow: start with intent, clarify it into a spec, then execute in a way that stays aligned with that intent.
Start with an idea, not a spec
You open Nuanced, sign in with GitHub. Once you connect ChatGPT, you can add a workspace using cmd+O.
You can also open the command palette with cmd+shift+P to see all available actions.
You can then start a spec, either by typing directly into the input or hitting cmd+N.
You begin to author a spec with a short description of what you want to build or change. This doesn’t have to be a fully formed plan, a rough idea is fine. At this stage, the input is treated as raw intent, not a prompt to immediately generate code. Instead of fanning out into execution, Nuanced opens a clarification space.
Progressive disambiguation before execution
Before agents start building, Nuanced clarifies intent using progressive disambiguation: an iterative process for defining what you mean before execution begins.
You are not asked to define everything upfront. The system helps you make decisions around goals, constraints, invariants, and what is out of scope, one layer at a time. The spec takes shape as you go, becoming more precise without breaking flow.
Generate tasks from the spec
Once the spec is clear enough, you can execute tasks derived from it. The agent begins working and shows the tasks in progress.
Where Nuanced is headed
Today, Nuanced helps you turn intent into a spec and execute against it. But our vision is to build toward a system that always maintains a clear link between intent and implementation.
We anchor this in the spec because human thought is now the bottleneck. The better we can help engineers express and reason about what they’re building, the more effectively we can direct agents and verify their behavior. The spec becomes the interface between human intent and machine execution.
In that sense, the spec also acts as a feedback layer, similar to CI/CD. CI/CD checks whether the code does what it’s supposed to do. Nuanced checks whether you’re building what you intended in the first place.
As agents generate code, Nuanced will surface when work drifts out of scope, violates assumptions, or introduces unnecessary complexity. These signals are meant to help you steer execution as it happens, keeping work grounded in what you are actually trying to build.
Try Nuanced
Nuanced is available now. We've been building Nuanced with Nuanced and find it significantly speeds up our workflow.
When you can regenerate a PR from a spec, it gives you the ability to easily experiment.
Try Nuanced today and let us know what you think.