The "whiteboard defense:" I should be able to pull you aside at any moment and ask you to explain any customer-facing system you've shipped. You should be able to clearly explain how it works and defend the decisions you made. This is my benchmark for responsible AI usage.
I don't expect line-level familiarity with the code. I don't care if you remember the exact function name or implementation detail. You may not even know it. I don't care.
But if I ask "why did you do X instead of Y?", "what happens if this actor behaves maliciously?", "what data structure did you use here and why?", or "where does this fail?" you should be able to answer confidently.
For PoCs, demos, experiments, whatever: I don't care. Generate 100% of it and understand none of it. Speed over quality every time in those specific scenarios.
But if you're shipping customer-facing work, you can't be shipping things you don't understand at a high level.
A lot of folks ask me "how do you work with agents in multiple repos at once?"
I have a very simple solution - the Home Repo
I have a single repo (the home) where all of my skills, steering files, wiki etc live.
I run my agent in the home repo, and then inside AGENTS.md I have pointers to the other repos:
```
For skills, clone mattpocock/skills to ~/repos/skills.
For Sandcastle, clone mattpocock/sandcastle to ~/repos/sandcastle
```
This is extremely simple and incredibly effective. The home repo lets you:
1. Put all your steering files and tooling in one place
2. Have a single spot to run all your agents in
3. Make sweeping changes over multiple repos
Talked about this in the course yesterday and folks are loving it (see below).
I'm sure you will too. Enjoy!
One tip to improve your grilling
Instead of talking about the 'what', try explaining more of the 'why'.
BAD: "I want to build an analytics panel for admins with graphs and filters"
GOOD: "Admins can't currently see an overview of the important data in the app"
If you start by explaining your proposed solution, the agent will stick to it. It'll assume all the important stuff is settled, and just grill you on implementation.
But if you describe the problem, you'll give the agent license to be more creative.
You'll end up with a much deeper, better conversation.
Which Claude model should you build with?
Our new guide breaks down when to use Fable 5.2, Opus 5.5, Sonnet or Haiku. It also covers when to adjust effort instead of switching models, and how to save cost by putting subagents on smaller models.
https://t.co/1VmXqhkZB0
We need to reconsider our priors on code readability.
Humans, compared to agents, are pretty slow at understanding large quantities of text. So in the old days, readability was important so the human could efficiently grok what was going on.
So readability now comes down to:
1. Can a human, if needed, jump in and understand the code
2. Does the code use the same domain language as the human describing the code?
1 helps with observability and the occasional spot checks you need to do on important PR's. 2 helps the agent translate the words you use into code changes.
In other words, readability is now a nicety, not a necessity.
The way agents 'read' code is different - good agents are all about gathering data about how the code works. They'll prod around with it, execute parts of it.
So 'readability' to agents really means 'verifiability'. How easy it is to mess about with that code to see it working.
Let's take this scenario:
- You have a huge module in your codebase that uses all sorts of complex performance tricks
- It has 100% test coverage
A talented human would need an hour or two to get comfortable working in that module.
An agent needs zero time. They verify it with the tests, poke about a bit, and they're good to go.
The takeaways:
- When judging a module (or a codebase), don't think about how easy the code is to read
- Instead, think about how easy it is to verify
- Design your codebase so modules can be tested and verified independently
- Feel free to sacrifice a bit of readability for performance
- Cyclomatic complexity and function size don't matter to agents
This might be the greatest issue report in history
Some folks wrote a paper about my /retro skill assessing its effectiveness
Incredible
https://t.co/IYo4rhz1Vp
We believe voice is the most natural way to interact with intelligence, so we created Dessa, the most authentic full-duplex speech model ever built. Talking with it feels like talking with a person…full of emotion, nuance, pauses, and a natural cadence.
https://t.co/r0qFLdvd6c
We launched OSS Scanner, which gives critical open source projects free, periodic vulnerability scans from our strongest models.
Each finding includes a proof-of-concept, and a patch where possible.
https://t.co/aonfpNG3WO
how do you trust your agents' work more? copy this post/link and give it to your @bot or agent!
1. codebase improvements: this is just good software engineering - better architecture, stronger types and invariants, clear boundaries. agents love to copy what exists and take the shortest path, so make the easy thing the right thing. categorically eliminate problems through code and you won't need to think about it again.
2. static analysis: lint rules, tests, CI, verification (eg TLA+). very token efficient ways to catch issues ahead of time.
3. prose: comments, rules, AGENTS.md, skills - anything that can't be enforced and requires agent judgment. use it minimally, but do use /create-verification-skill.
4. human review: the hardest to scale. at the rate agents land code, it's pretty much impossible to thoroughly review every PR, so spend that effort on the highest leverage point, designing an environment where agents do the right thing by default.
this forms an inverse pyramid: you want most of your effort at the top, least at the bottom. codebase improvements are deterministic, making it more token efficient, and lets you sleep more soundly at night.
install https://t.co/u9xIlN3eN0 and create a new Project:
1. look through my slack/chat messages and code review comments where i've given feedback on PRs, code, architecture
2. use /recall on my past transcripts to learn how i steer agents
3. /poteto-mode use /correct and /architect on past commits to find the most common pitfalls agents fall into, then propose a plan to rearchitect the code i own so it's more agent friendly. answer open questions with prototyping rather than defer to me, and back the plan with real data.
4. before you begin, use /sharpen + /in-your-own-words and confirm this prompt with me
Prompt of the day:
/writing-for-agents my AGENTS.md is a hot mess, propose a series of restructurings that:
- Remove no-ops
- Use progressive disclosure
- Move instructions to CODING_STANDARDS.md
Apply your work over three subagents, each more radical than the last. Create a single PR.
AGENTS.md is the most common source of token inefficiency. This prompt kills it dead.
Effect v4 is here.
One ecosystem. Zero dependencies.
The next chapter of Effect and the foundation for building reliable software and AI agents in TypeScript.
Follow the link below to claim the credit or run /claim-credit in the CLI. You’ll need GitHub connected to start a session. Claim by Oct 7. Terms apply.
https://t.co/TzoO6fzJHB
A great idea I'm stealing from @dexhorthy:
When you first start building a software factory, make it TINY.
Don't get it to triage every issue in your repo. Just do one per day.
Check its output. Adjust it. Keep going with your regular work.
As you begin to trust its judgment, get it to triage TWO issues per day instead. Then five. Then ten.
Start small. Adjust. Build trust. Expand.
Pretty incredible how the skills repo by @mattpocockuk is only 6 months old, and has more stars than the React one. We had to sit down and talk. Timestamps:
00:00 Intro
05:48 How Matt got into tech
10:14 How Matt got into open source
12:58 Joining Vercel
18:39 Total TypeScript
23:21 AI’s impact on technical education
30:32 Building reusable skills for AI coding agents
40:46 The “smart zone” vs the “dumb zone”
45:02 The wayfinder skill
47:52 Why agents excel at software engineering
50:54 “Leading words”
1:01:10 Learning the fundamentals
1:09:17 Local vs. cloud agents
1:12:36 Planning vs. course-correcting
1:18:13 TDD and agents
1:23:06 Living in the UK
1:24:21 Teaching: the human part
1:28:36 Advice for junior engineers
1:31:07 Gardeners and great engineers
1:34:01 Book recommendation
Brought to you by:
• @turbopuffer – vector and full-text search engine built on object storage. It’s fast, cheap, and extremely scalable. https://t.co/w9y67Gs8ab
• @linear – the product development system trusted by 40,000+ teams to plan and ship. Get six months of Linear Business for free: https://t.co/knIF2mcz9p
• @WorkOS – The fastest AI-native teams have to slow down for the hard problems. WorkOS makes sure auth, for your app and your agents, is never one of them. https://t.co/aiAee0oF5h
Thanks for the convo @mattpocockuk!
/retro will now aggressively look for opportunities to turn fuzzy rules into deterministic checks
It'll propose custom lint rules, pre-commit hooks, or CI workflows.
Found an error? Do a /retro, and make it impossible next time
https://t.co/7PJwGitH3G
We're publishing our most detailed threat intelligence report to date.
It covers how people tried to misuse Claude—for cyberattacks, influence operations, surveillance, biology, and building weapons—and how we found and stopped them.
We disrupted every operation in the report, and used the lessons from them to strengthen our safeguards. Where appropriate, we also shared what we found with authorities and other AI companies.
These cases are not typical: we’re highlighting some of the most sophisticated misuse we’ve seen. But they’re especially important to discuss, because they show us where AI misuse is headed, where our safeguards work, and where they need to improve.
We’re publishing this report so others can spot the same activity on their own platforms, and so we can give the public a clearer view of how emerging threats develop.
Read the report: https://t.co/0EJUnYEgfz