Pinned Tweet
Hey everyone, I’m Derek. I lead engineering at Atlassian for Jira and Developer AI. I’ve been a builder most of my career at both startups and big tech. Grew up in Canada but now based in Seattle.
I’ll start sharing more of what we’ve got cooking. Would love to connect - DMs are open or feel free to drop a question.
Model naming as a window into corporate psychology -
Anthropic: literary forms
OpenAI: cosmic bodies
Google: chemical elements
When a coding agent says it's done, what do you look for/do to be *completely* convinced the change is good and ready to merge? What are red flags?
I often ask an LLM to do a long-running task, and then come back to reams of scrollback. I mostly just read the end and find it puzzling as it refers to various things that have long scrolled past or were embedded in its reasoning but not output. Seems like a clear post-training opportunity to summarize succinctly and inline key definitions/references that were developed earlier.
This seems like the fundamental problem with formal verification methods I'm seeing: if you trust an LLM to flawlessly convert your legacy codebase to a formal spec, wouldn't you just trust its initial code output anyways?
We spent fifty years making proofs impossible to fake. Then we let the coding agent pick what to prove.
A research paper this month put a number on it.* AI wrote the formal spec, AI wrote the proof, the verifier accepted both. Then humans read the specs. Close to 60% proved something other than what the author meant. Not wrong proofs. Wrong specs.
The verifier was right every time. That's the problem. Left to choose, the agent picks properties that are easy to prove and say nothing about the program, and the checker can't tell a useless theorem from a useful one. I'm calling it vibe verification: the agent writes the spec and the proof, the checker goes green, nobody reads the spec. This applies to Verus, Lean, Bend, TLA+, Dafny, [insert favorite formal language here].
Here's an example of an agent failing at something that feels too simple to fail:
Ask for a verified sort. It writes a spec that says "the output is sorted" and proves it. What the spec never says is that the output has the same elements as the input, so a function that returns an empty list satisfies it, and the verifier accepts the proof. Trivially satisfiable specs are the default failure, not an edge case.
Here's a formula that actually works. Don't say "formally verify the codebase." Say "show that [property] holds in [component]." A property is a precondition (true going in), a postcondition (true coming out), or an invariant (stays true the whole time).
For example, "A session token is never accepted after the logout that revoked it" is a good invariant.
The bottleneck is moving from code review to intent review, and the spec is where intent lives. So: read the spec before the code. Write 3 inputs it must accept and 3 it must reject. Treat a model-written spec with utmost paranoia and rely on your judgement as an engineer.
Formal verification for software doesn't automatically create trust, it moves it, from the code to the spec. If a human didn't read the spec, you didn't verify anything. You vibe-verified it.
Follow me for more on verification and agentic engineering.
* Wang, Jiang, Liu et al., "VerusEval: Evaluating LLM-Generated Verus Specifications Beyond Verifier Acceptance", Shenzhen University, arXiv 2610.26464, October 2026
Readers added context they thought people might want to know
The paper used Llama and ChatGPT-4o, a 2.5 year old model that's not even available anymore. The tweet is 100% ai generated.
pangram: x.com/AndrewNWest/st…
All this intelligence and knowledge is sitting in an LLM and Jev and Clairic found novel ways to tap that by training new output heads for classification and regression. Wondering what other novel use cases can be unlocked this way?
GitHub said that commits have grown 5x year over year as of Sept. But all of us are users of software everywhere everyday.
Has the software we use gotten 5x better?
Nowhere close. What are the problems we need to solve?
I still remember the days when everyone would get out their phones to check-in immediately after getting seated at a restaurant.
Massive influence on an entire generation of builders.
Foursquare was acquired last month. The outcome was disappointing. It's taken me a while to write this, but I think I'm finally done grieving it. Here are some thoughts on our final years, an effort to honor the team who helped build & maintain FSQ's legacy, and my attempt to finally get some closure. teendrama.substack.com/p/som…
As the subsidy era comes to an end, we'll see truly which usages are fundamentally uneconomic. A lot of low-end usage will not be (no one spends thousands of bucks a month on a hobby).
Cost governance is also going to be critical in enterprises...
🦔Microsoft canceled its internal Claude Code licenses this week after token-based billing made the cost untenable, even for a company with effectively infinite cloud resources. Uber's CTO sent an internal memo warning the company burned through its entire 2026 AI budget in just four months. American AI software prices have jumped 20% to 37%, and GitHub (owned by Microsoft) is dropping flat-rate plans for usage-based billing across its products.
My Take
The AI subsidy era is ending in real time. The same company that put $13 billion into OpenAI and built the Azure infrastructure powering most of Anthropic's compute just looked at the bill from a competitor's coding tool and decided it was not worth paying. That is not a productivity failure on Anthropic's end. Token-based pricing is forcing every enterprise customer to confront the actual cost of running these models at scale, and the number turns out to be far higher than the flat-rate experiments suggested.
This ties directly to my Gemini Flash post yesterday. Anthropic, OpenAI, and Google all raised effective prices in the last six months. Enterprises that built workflows assuming AI costs would keep falling are now watching annual budgets evaporate in months. Two outcomes look likely from here. Either enterprises scale back AI usage to fit budgets, which slows the revenue ramp the labs need to justify their valuations ahead of IPOs, or the labs cut prices and absorb the losses, which makes the unit economics worse at exactly the wrong moment. Both paths land in the same place, the numbers stop working, and somebody has to take the writedown.
Hedgie🤗
Is Claude Code better at backend than frontend?
After analyzing 2,333 Claude Code sessions, the answer is definitively...
No. But also yes. Not joking - details below.
Using the SWE-chat dataset, we segmented CC sessions into frontend-only and backend-only.
The frontend sessions had success rates pretty much identical to backend sessions.
But when we looked deeper:
- individual frontend prompts failed 34% more often
- users reprompted CC more frequently on frontend
- median lines of code written by humans was 43% on frontend compared to 17% on backend
So overall session outcomes were similar, but frontend needed a lot more handholding to get there.
It shows that chat is insufficient for frontend. It's too cumbersome to describe specific visual changes in words. That's why we're building @handledotai
Full report here → gethandle.ai/is-claude-code-…
Self-driving cars are going mainstream just in time for us to use that freed up commute time to watch our agents work
Coding agents are great for first drafts of UI, but clumsy and slow when it comes to refining details.
The solution is to combine both: explore with an agent, but then be able to select a component, make direct edits and round-trip the changes back to code.
Everything's done directly in the live product so there's no gap between design and reality.
Some tokens are harder than others.
When an LLM generates text, sometimes the choice of next token is obvious and other times it’s uncertain because there are many plausible options. I built Prism to help visualize easy vs hard tokens. I’ve found that seeing this gives me intuition into how an LLM operates.
Which tokens are hard? The beginnings of sentences and phrases are often uncertain as that’s when there’s a big decision to make, while the rest follows. In code, too, starts of lines and blocks are hard — and, of course, identifiers. Models struggle with naming just like all of us!
Try it on your text: tonkotsu-ai.github.io/prism/
Some of my favorites...
VC speak: tonkotsu-ai.github.io/prism/…
Constitution preamble: tonkotsu-ai.github.io/prism/…
Jabberwocky: tonkotsu-ai.github.io/prism/…
Simple neural network: tonkotsu-ai.github.io/prism/…
GitHub repo here: github.com/tonkotsu-ai/prism
Check out Prism. It runs a tiny 500M parameter LLM in your browser on a piece of text and visualizes the entropy of the probability distribution computed for each token -- effectively how confident the model is in predicting each token.
For code you can see that the model is unsure when it needs to pick an identifier or start a new line. It's a fascinating glimpse into how models operate -- what is "easy" for them and what is uncertain.
Links below.









