founder @nuanced_dev prev 7 yrs @github, @UniofOxford @uwaterloo writing about AI, code, and how humans actually understand software
rent free in your head
Joined August 2009
- Tweets6K
- Following1.7K
- Followers6.7K
- Likes33K
Pinned Tweet
we made a document editor for building software with agents
write a spec. get comments from an agent that has read your codebase. work through the decisions, then have it build.
Introducing Nuanced Canvas.
chat is great for one-off answers or fixes. it’s a pretty terrible interface for developing ideas over time.
the problem is that everything becomes ~*another message*~
if you wanna change one assumption, write another prompt. disagree with part of a plan? select the relevant text and paste it back into chat to explain what you mean. wanna revisit a decision from yesterday? ask the agent, get a vague summary, then dig through the backscroll of an enormous thread to reconstruct your own reasoning of how you got there.
even the boundaries of a chat are poorly defined. where does one conversation end and another begin? what belongs in the same thread? when does a discussion become a decision? and where does that decision live afterward?
it’s an awkward way to think because the thing you’re working on never really exists independently of the conversation about it.
that’s why we're building nuanced.dev around living documents. i want humans and agents working directly on shared ideas, with a durable record of how those ideas evolve rather than endlessly generating plans that disappear into chat history.
dawg this is a bleak way to think about love.
your life partner isn’t an early stage investment?? earning potential is a poor proxy for who they’ll be when you need them most.
this year I spent six weeks hospitalized before giving birth and underwent major surgery. I needed my husband’s help just to get to the bathroom. on top of a serious pregnancy complication, i was navigating several family crises.
the most valuable thing in a partnership isn’t someone’s potential for success. it’s their commitment and the consistency of their care regardless of your circumstances. in good times and bad etc etc
One month into dating, her boyfriend’s startup was acquired by NVIDIA.
Our #1 SF Dating advice: Lock it in before the acquisition
in an era of corgi girls and increasingly bizarre transactional relationship discourse, I was genuinely excited for a podcast by two incredibly successful women
success and character are obv not mutually exclusive, but what could’ve been a substantive conversation about ambition and relationships instead reproduced the same status anxiety that already dominates tech, just repackaged as relationship advice.
I think they’re both smart and have much more to offer. I hope they take the criticism to heart without taking the hate to heart.
i get the vision of a software factory where engineers review specifications instead of code, but i think correctness and understanding are two very different problems and an AI-generated spec is the wrong interface for solving the latter.
formal verification can prove that code satisfies a spec but it can't establish whether the spec captures what we intended, or whether we've specified the right things in the first place.
i wrote about this in “plan mode is dead.” replacing thousands of lines of generated code with thousands of lines of generated natural language specs doesn't solve the comprehension problem. it just moves it up an abstraction layer. my eyes glaze over reading ai-generated text!
cheaper implementation means the cost of misunderstanding what we're building becomes more consequential.
we shouldn't need to inspect every implementation detail, but we do need interfaces that make intent, assumptions, and the boundaries of what's actually been verified legible enough to exercise judgment.
How do you _guarantee_ your agent's code is correct? You prove it.
Introducing Proof Driven Development Kit (PDD Kit) from @MSFTResearch.
PDD Kit helps turn your plan into a formal spec, then proves the agent's code meets that spec for every input. No vibe verification. PDD Kit is integrated with @GitHubNext's Chopin, so you can plan as a team.
PDD Kit takes an app's login flow from intent to a verified pull request:
It discusses your code, infers your intent as it goes, and proposes a formal spec in Verus, a proof language for Rust.
Once you approve the spec, the Verus verifier automatically proves the code meets it.
Where proof isn't possible, it falls back to empirical verification with tests and computer-use agents (CUAs).
It works on Rust today. No new language, no change in how you produce the underlying code, making formal methods more accessible.
The goal is a verified software factory, where engineers review specifications instead of code.
Come see it in action at GitHub Universe, Oct 28–29. Swing by the Speakeasy and ask for GitHub Next!
you can disagree with what they're saying without being racist or commenting on their appearance
How do you know there isn't a better soulmate out there?
@vivianmshen on how her husband, an early investor in Anthropic, Mistral, OpenRouter, Black Forest labs and now founder of Amp was once a lost soul.
Listen: youtube.com/watch?v=cpvozOFq…
this is @jmvldz and i. our daughter is the living embodiment of the worldwide latina belt.
fusions go crazy. nihari birria tacos are fire.
there’s a HUGE difference between having an idea and being able to articulate it.
i’ve sometimes felt slow as an engineer, but i’ve come to realize that the friction I felt was developing my product+eng intuition. struggling with complexity forced me to interrogate the abstractions/ux that sustained it and to distinguish necessary complexity from unnecessary friction. this helped me develop a sharper sense of where real problems lie.
writing is a big part of that discipline. it forces you to turn vague intuitions into explicit reasoning and exposes the gaps in your understanding. the difficulty of articulating an idea is often evidence that you haven’t fully understood it yet. it’s the process of connecting your felt intuition to something tangible.
when code was expensive to write, the act of writing it forced you to have confront your assumptions beforehand.
now it’s easy to go from a vague idea to implementation without ever developing a clear opinion. but the cost of that is (1)premature commitment to an idea you haven't evaluated (2) the false sense of confidence created by working code.
some of the friction we removed was doing useful cognitive work.
this is why I’m building nuanced.dev
it gives you a place to thoughtfully examine your assumptions and develop your ideas clearly
writing forces you to wrestle with an idea
sometimes you don’t really know what you think until you try to write it down
when you don’t write down your reasoning, the decisions still get made for you. you just lose your ability to question them later.
the work to think through why something matters will always be useful.
nothing prepares you for loving someone this much. the joy is almost unbearable, and so is the vulnerability. your whole world becomes a little person who has no idea how completely they hold your heart
this is exactly why we built Nuanced Canvas nuanced.dev
agents produce code at a rate that quickly outpaces human understanding, but figuring out what to build, thinking through tradeoffs, and maintaining a clear mental model of our software are still hard.
we need better tools for thinking, not just faster tools for executing.
If AI makes you 10x faster at coding, why is your team not shipping 10x faster? Amdahl's law has the answer...
The law says the overall speedup is capped by the part you did not speed up. With `p` as the fraction of the work you accelerate and `s` as the speedup on that fraction, speedup is computed as attached.
Now plug in some numbers. Say writing code is 30% of the time from idea to production, and AI makes that part 10x faster. The overall speedup is 1 / (0.7 + 0.03), which is about 1.37x. Even if coding is half of the cycle, you get about 1.8x.
These numbers are illustrative, so use your own, but the shape stays the same. The rest of the cycle is still there:
- Figuring out what to build
- Aligning product, design, and other teams.
- Code reviews, which are now more than ever
- CI and CD takes the same wall time as before.
- Debugging and incidents, where code that nobody on the team wrote line by line takes longer to understand.
In fact, it can get worse than Amdahl predicts.
Faster code generation increases the load on every stage after it, so the review queue grows and the bottleneck shifts. A team that writes 10x more code with the same review capacity is just building a bigger queue, unfortunately
So if you want the team to actually ship faster, measure the whole path from idea to production and find where work waits. Then apply AI there too: review, test generation, flaky test triage, deploy safety checks. Otherwise, you have optimized the part of the system that was never the constraint.
Speeding up the typing was always the easy part :)
ayman nadeem retweeted
The trajectory is clear
New on our Frontier Red Team blog: using Claude to formally verify software at large scale.
Formal verification can prove that code is free of certain bugs, but historically it has only been feasible for small codebases (or required a lot of expert time).
With AI models, however, this is beginning to change. In collaboration with @theoremlabs, we used Claude to prove security properties in over one hundred real-world open-source libraries over the span of a few weeks.
Read our research in full here: anthropic.com/research/forma…
ayman nadeem retweeted
today in trying to be more ambitious: i asked for 100 ms startup time on our electron app. it did not go how i'd hoped
we're building a markdown editor for building software with agents @nuanced_dev. i'm a big fan of @zeddotdev and have always wanted to build an app that starts as fast as possible. i close and open apps many times a day, i prefer to quit an app i'm not using to protect my mental context
so upon reading @felixrieseberg's post last night, i went about actually being more ambitious with startup speed. it already starts fast, i'd previously profiled it to around 420 ms which feels solid. Opus 5.5 said that was probably the limit without going native.
but felix said to be unreasonable
so i was unreasonable. i asked for 100 ms.
and let me tell you, not all software is free. not even close. eking out performance gains is not something you can hill climb in a night. Fable 5.1 did manage to get it from about 420 ms -> 320 ms with a modified electron
the funniest direction Fable took was a hybrid where a native window starts fast and gets replaced with electron soon after. it technically hit 158 ms, but you're looking at the wrong ui for most of it. i checked the demo video and it looked insane, the native ui didn't match the electron ui and you just see a flash of it before electron takes over
the only way to get lower is going native or compiling typescript directly to a binary. i'm excited about scriptc but it's early and nowhere near able to compile a monster like electron. felix is a maintainer on electron so he may have thoughts
the models can crank away but there's a limit without better libraries. we need everything to be faster! we need electron -> binary compilation, maybe @jarredsumner will ship that with @bunjavascript but it sure won't happen with one agent cranking away in a night
next experiment is stripping electron down even further, will report back!
i think what’s tough about codex right now is the mental overhead of relearning where everything is. everything is compressed into chat, but the buttons keep moving.
i was making gifs for the prod launch, and sometimes there’s a download link, sometimes i have to locate the file in finder, sometimes i have to ask for it. same thing i’m trying to accomplish, different ways to get there. even how to interact with a preview isn’t consistent.
i get that dynamic interfaces sound cool in theory, but chat is a difficult form factor for this. discovery has to be really intuitive, because otherwise i’m figuring out how to use the tool all over again while trying to finish something.
5. The document is alive.
Specs often become outdated as the software changes. In Canvas, I can return to the same document to revisit a decision and edit the section I want to change.
The document is an ongoing interface to the software.
Nuanced Canvas helps you read and write about your software, and then the agent implements your changes in an isolated Git worktree. You review the diff and ship a PR.
Available for Mac.
nuanced.dev/