Coder & Rabbi, async. Former: StartupVet, DevBootCampGuru, Mentor, Consultant, Speaker, Author, ShorePHPFounder, NYPHPOrganizer. Now: Just trying to human well.
I refactor legacy coders.™
Joined December 2012
- Tweets42.2K
- Following1.5K
- Followers5.3K
- Likes58.5K
Yitz Willroth™ retweeted
My software factory is shipping full features overnight, planned out with adversarial code reviews and CI at each step, and leaves me a comprehensive UAT checklist in one final PR so I can look everything over and test before I release. This is how I work now.
Yitz Willroth™ retweeted
Over a year ago, I stopped reading code and started automating adversarial agents to perform recursive code reviews instead.
The result: low-defect systems that do what I want. Can't believe anyone engaging seriously with these tools still believes human code review is superior
Yitz Willroth™ retweeted
There's been a lot of debate about AI vs human code review recently. Here's some actual data and observations from inside Meta:
- Engineers now push ~3x the code they did a year ago. Human review capacity obviously didn't triple.
- In an analysis involving 535k+ reviewed diffs, the production-incident rate for AI-reviewed diffs was 1/50th that of human reviewed.
- The revert rate for AI reviewed diffs was 1/3rd of the human reviewed.
- Median review wall time dropped by 35% compared to human-reviewed diffs.
- Experts then looked at every production incident caused by AI-approved diffs. A human reviewer wouldn't have caught any of those issues anyway in a manual review.
- Meta's internal coding agent lands ~3,000 diffs a week, and 59% need zero human edits.
Human review as default for most code changes is already obsolete, and might even be riskier.
Source in comment below.
Yitz Willroth™ retweeted
I don't think we need less software devs, but I do think if you're not fully embracing AI in your software dev work you're at a very high risk of being a casualty for someone who will. It's simply vastly more productive and if you're a holdout you simply can't keep up
Yitz Willroth™ retweeted
you used to write code by hand and when it didn’t work you had to go into the codebase and understand all the functions
sometimes people would go on for days about variable names and we would argue about what programming language was better
Yitz Willroth™ retweeted
Anyone hiring?
I'm looking for my next PHP/Laravel opportunity: senior fullstack dev, engineering lead, AI, DevOps, DB admin, all that stuff.
If you know someone looking for a cracked engineer who knows Laravel like the back of his palm, please send them my way.
Thanks!
Yitz Willroth™ retweeted
hot take: we’re closer to the end of code reading than most devs realize
once agents can generate, test, review, debug and maintain code reliably, reading thousands of lines of implementation detail becomes a terrible use of human attention
the next generation of devs won’t be defined by how much code they can read
they’ll be defined by how well they can direct machines that write it
and yes, this is probably going to piss off a lot of devs
Yitz Willroth™ retweeted
seniority in any role is often just the ability to take a poorly shaped prompt (eg “this is bad, make it better”) and do the right thing
the more senior you are, the more misshapen the prompt you can handle
some of you may know this by the name of “handling ambiguity” from your favorite career ladder
Yitz Willroth™ retweeted
Two classic books seem particularly relevant for the current age of software:
1. Mythical Man Month, because cohesion of vision is more important than ever and volume of code != value
2. High Output Management from Andy Grove, particularly that chapter on orchestrating the coffee shop, because that's what our jobs as software builders look like now
Yitz Willroth™ retweeted
Getting more and more convinced that if you understand the "shared language" of your codebase...
(i.e. the terms used, the names for things, relationships between them)
...AND those terms are used consistently in the codebase, then you understand the codebase.
Whether you read the actual code or not.
DDD has never been more powerful.
Yitz Willroth™ retweeted
Want to know why a lot of software professionals say you don't need to read (all) the code that AI produces anymore?
It is because our test suites look like this.
Yitz Willroth™ retweeted
I’m still reading the code agents generate, but I’m increasingly looking at it from a higher and higher level.
Instead of trying to manually catch every problem in review, I’m building deterministic tools that agents can use to enforce strict rules around how our code should be written.
The more engineering knowledge we can encode into tools and guardrails, the less we have to rely on humans spotting problems in a diff.
AI agent proofing our codebase so we can ship faster with more confidence.
Some of the guardrails/tools we’ve been adding:
* Request/command/test profiler so agents can diff performance before/after changes
* Automatic CI profiling when sensitive code paths change
* Deterministic static analysis of database migrations, with hard/soft rules and explicit PR acknowledgements
* Deptrac to enforce architectural boundaries
* Find unused dead code with Psalm static analysys
* Infection mutation testing
* Local coverage tooling so agents can verify coverage before pushing
* Changed-files-only checks so agents can run fast verification loops locally
* CI optimized from ~8 minutes to ~1 minute
The goal is to make agents responsible for more of the verification loop, not just writing the code.
Yitz Willroth™ retweeted
AI agent proofing our codebase so we can ship faster with more confidence.
Some of the guardrails/tools we’ve been adding:
* Request/command/test profiler so agents can diff performance before/after changes
* Automatic CI profiling when sensitive code paths change
* Deterministic static analysis of database migrations, with hard/soft rules and explicit PR acknowledgements
* Deptrac to enforce architectural boundaries
* Find unused dead code with Psalm static analysys
* Infection mutation testing
* Local coverage tooling so agents can verify coverage before pushing
* Changed-files-only checks so agents can run fast verification loops locally
* CI optimized from ~8 minutes to ~1 minute
The goal is to make agents responsible for more of the verification loop, not just writing the code.
Yitz Willroth™ retweeted
Reading the code is purely ego thing.
If you have strict guidelines and enforce code architecture - SOTA models will produce code that adheres to those rules (ie "Best practices")
AI will write tests, most of you will never.
AI can review itself, find repetitions and issues.
In rare cases AI would over-engineer solution, that's why planning mode is so important.
It's also concert of
"there's a SKILL for that"
I don't oneshot.
I iterate. Plan. Review. Document. Build. Test. Review. Test. Audit.
All are skills, workflows, mostly automated.
Reading the code becomes informative practice. Because we're at the point of 95+% deterministic outputs.
Sufficient for pretty much all of your projects.
A sliver subset of development work with unpopular languages or problems models never seen in training...
But it ain't you, bruh. Most of devs on here are not working with that. It's truly rare.
So many snarky comments here from people who are supposedly writing code so complex than modern models can’t write correctly.
I’m not sure why is that a flex.
Do you understand you are still typing gibberish like a caveman while the rest of us are making money by talking to a magic box that’s helping us do our jobs?
Yitz Willroth™ retweeted
for anyone still not trusting ai can write all your code, go spend a week setting up an actual proper agent harness + implementation pipeline (loops/templates)
you'll talk differently afterwards
Yitz Willroth™ retweeted
Great event!
If you are ready to start thinking about next year, I have an idea…
iamkevinmckee.github.io/lara…
Yitz Willroth™ retweeted
Software quality now depends on the constraints you set around your agents.
When humans manually wrote most of the code we could look at the code itself for signs of quality. Is it clean? Is it thoughtful? Is it fast? Can another engineer understand it? Does it have tests?
Agents can now generate more code than people can read. When code generation scales beyond review, quality - checks for one or more of correctness, maintainability, security, performance etc - increasingly has to live somewhere else.
It moves into the harness, environment and operating system around the agent.
This can be the tests and deterministic checks that decide what the system is allowed to do (amongst others). Your constraints are what may eventually enable loops of agents to deliver production software reliably. They can include unit tests, property tests, acceptance tests, mutation testing and quality metrics.
This back-pressure lets the system resist bad work before it becomes somebody elses problem.
Set your constraints. They decide whether the code your agents generate is good enough to ship.
ALT set the constraints around your agents - correctness, security, maintainability and other dimensions.