@_KevinSmith

VP Eng @AxisCareUS // Champion of healthy software teams that make a big impact and happily stick around for the long haul. // I love puzzles.

Nashville, TN
Joined October 2009
Two kinds of senior engineers right now: One is dabbling with AI and waiting to see how it all shakes out. The other has already pushed the agents to their breaking point, has hard-won opinions about where they fail, and is shipping in hours what used to take weeks. We’re hiring the second one. Fully remote. axiscare.bamboohr.com/career…
1
4
727
Kevin Smith retweeted
Replying to @abimaelmartell
• comments go stale very quickly and confuse agents and people • they are often used by agents to explain workarounds that would've been better off actually fixing the code instead • they are not enforceable and waste your agents' tokens my point is that moving prose (comments, rules, agent.md, skills) into deterministic lint rules, better API design/types, is far more effective, enforceable, and token efficient. comments are simply a crutch that agents will happily misuse
36
12
11
526
20,356
Kevin Smith retweeted
The only moat is understanding your customers' needs and future tech capabilities better
Technical moats are mostly over at this point. If you’re building something that is meant to be durable, the only moats now are: • Proprietary data • Network effects • A physical component
5
13
2
146
5,601
Kevin Smith retweeted
"It's such a delight" ... and people keep asking: well if AI is so good, where's the great software? Right here, baby: ampcode dot com
Kept hearing a lot about @AmpCode and I've been impressed with @thorstenball's commentary on AI, so with Adam's tweet I figured I should just take it for a spin. He's right, it's such a delight. It's everything I was hoping the future of making software could be, and there have been hints in all the tools I've been using, but it's already here. And so well designed. Clearly the Amp team not only uses it but sweats the details. So low friction. Everything I've been trying to cobble together myself, but it's just there, ready to go. I can focus on building my thing, and I can do it from anywhere. Web, mobile web, Mac app, iOS... it's crazy how seamless it all feels.
5
3
81
5,783
Kept hearing a lot about @AmpCode and I've been impressed with @thorstenball's commentary on AI, so with Adam's tweet I figured I should just take it for a spin. He's right, it's such a delight. It's everything I was hoping the future of making software could be, and there have been hints in all the tools I've been using, but it's already here. And so well designed. Clearly the Amp team not only uses it but sweats the details. So low friction. Everything I've been trying to cobble together myself, but it's just there, ready to go. I can focus on building my thing, and I can do it from anywhere. Web, mobile web, Mac app, iOS... it's crazy how seamless it all feels.
Building software in anything other than @AmpCode orbs feels like eating broken glass in comparison. But it’s frustratingly one of those “you can’t understand why it’s better until you just use it” tools, a lot like Tailwind was. Use it, and be ruined.
2
1
2
21
6,510
Kevin Smith retweeted
"The culture on X today is remarkably friendly and inclusive. It is a cheerful place", I couldn't agree with @daringfireball more. X is the place to be if you genuinely like technology and progress. Just such a delightful optimism here. daringfireball.net/2026/10/x…
124
141
30
3,059
149,474
Kevin Smith retweeted
Agents write code "much better on average at scale" is right. The "at scale" part comes from verification. Agents make checking cheap. The stuff that made "Good Code" expensive (tests, benchmarks, specs, real e2e runs) is now a cheap thing you can ask an agent for. You can improve the checks. So our work is less "review every line" and more "build loops the agent can run itself". Give the agent a way to verify the work. That loop is where quality comes from. And make taste compound. When the agent gets something wrong, write it down (shared config, a hook, a test) so it doesn't happen twice. A human still owns what ships but now they're reviewing evidence and not just diffs.
codebases have always contained slop. we have always been okay with this because code rarely needs to be perfect, outside of mission critical "hard" (eg embedded) software. swe is a unique form of engineering because you're often building something that constantly evolves and is almost organic - user tastes change, your mental models evolve, and features come and go. admittedly, i and many others who've been coding for a long time were initially (like back in 2024) skeptical that agents would write production code. "but what about all the slop that would enter our beautiful codebase?". well, even before, we had human slop, and there was a lot of it! if we're being truthful, most people call "code i didn't write" slop. the reality is that 99% of people (i include myself in that number) don't even know what Good Code looks like, let alone be capable of writing it. i would propose that Good Code is: • correct • bug free • fast and cost efficient to run it has always been exceedingly difficult and expensive to write truly Good Code, because for the longest time (maybe @bendlang will change that), code was not something you could cheaply and formally guarantee to have all 3 of these properties. this is why writing hard software is much more difficult and expensive, because depending on the use case, you may only get one chance and so you have to be right from the start. but the vast majority of software we use does not need to be Good Code to provide value to users. in fact, it is very likely that most software we use is not formally verifiable! we accepted some bugs in exchange for velocity and progress, so we rely on tests and o11y instead and have adopted a more incremental approach. this is a good thing! agents help us move faster, and if you're open to the idea, are capable of helping us write better code. it won't be Good Code (that is still expensive), but it is likely to be much better on average at scale. the new craft of swe is to figure out how to do this. it's your job now! if your productivity with and without agents is not significantly different, you're doing something wrong. but it's not too late to embrace it and use it as an opportunity to learn a whole new skill tree
85
54
16
628
49,716
In celebration of some major marble moves this past weekend, I decided to add week-to-week marble rank changes to the table. Enjoy!
2
4
1
29
2,928
Kevin Smith retweeted
I've been thinking more about the this reply and I think I figured it out. > how did you trust it before when humans wrote it? you mostly didn't, not really. you trusted the tests, the fact that it was already in production somewhere similar, the author's track record, and the reality that most of the time the bug would show up in monitoring before it became a real problem. the diff was honestly a ritual more than a guarantee. we pretended like line-level review was a safety net because we didn't have better options and the volume was low enough that it felt manageable. but agents just make the old ritual obvious. once you're landing thousands of changes a month the idea that someone is carefully reading every diff starts being theater. trusting agent output is the same problem as trusting human output, just with higher throughput. I think the answer is still to stop treating the change as the thing you trust and start treating the environment as the thing you trust. if an agent can run the code, drive the ui, check the invariants, and get blocked by the same constraints a human would, the fact that it wrote the patch matters less. every time you find yourself wanting to open the diff "just to make sure," that's signal that something in the system is still relying on human eyeballs instead of a hard constraint. the code review as we know it is already on the way out. most of what we call review today will turn into risk scoring and continuous verification. low and medium risk work will land after agents and checks have already exercised it. humans will still be involved, but not by reading patches. they'll just be deciding what outcomes matter, whats not allowed to break, and which constraints are worth making permanent. the job now is to continuously make the system good enough that you don't need the diff to feel safe.
Replying to @compuficial @Bots
how did you trust it before when humans wrote it?
26
31
4
349
24,136
Kevin Smith retweeted
You should probably work on raising the ceiling, not the floor — Nat Friedman
2
7
61
2,610
Kevin Smith retweeted
A good general rule for optimizing your coding loop right now is if something *feels* tedious and annoying, you should take a step back and ask yourself how an agent or simple tool an agent can build can make it less tedious. For example, if line-by-line code review is tedious, what artifacts or proofs could you generate that would give you both understanding and confidence in a given change so that reviewing it isn't a slog?
16
13
6
193
11,281
Getting dialed in with week 7. cfbmarblegame.com/?season=20…
3
8
4
29
7,285
My definition of high quality software seems durable for a good long while: "High-quality software is both valuable to the business now and easy to change later."
1
159
in the excellent "The Reverse Centaur's Guide to Life After AI", @doctorow makes an excellent point: LLMs are exhausting to work with because they generate statistically likely text which means mistakes *look* right, so you have to be operating at an intense level to catch them
16
74
8
690
15,663
Kevin Smith retweeted
"your edge right now is understanding the possibilities and being curious" Using AI for software engineering is now the default. The engineers I've seen who have the edge are ambitious and have been grinding with agents for years on the job at this point. It's a compounding effect. For teams still unsure or catching up, the smartest thing I can advise is to be even more ambitious and aggressively share what you learn with your peers. If you do all this work privately, only you benefit. If your team only gets to experiment with AI after hours, you've quietly told them using it doesn't count. Senior engineers should be the first to make this shift. Their decades of taste in system design and failure modes is the secret sauce that makes agent output good. They should direct their experience to building with agents better safety. Then show whats working to others to replicate.
🗞️ if your team is too busy doing their 'normal job' to experiment with AI, you're preparing them to be replaced ghuntley.com/replaced/ In this post, I guess this's the last time I'll say it. AI use is no longer optional if you wish to be employed. What follows is advice for current employees and hiring managers on how to hire in 2026 to source AI-first candidates.
76
54
4
637
38,956
If you don’t feel this way, then you are missing out You owe it to yourselves to explore these new magical tools and see what they can do for you and the people you care about
It’s feeling really magical inside of Shopify right now. It’s clearly the greatest time in the history of tech industry right now. I hope it feels similar everywhere else.
3
1
1
70
9,288
Kevin Smith retweeted
2026 is fundamentally no different than previous years. Amateurs can create something that appears to work. But they’re unlikely to create something that is secure, performant, consistent, accessible, usable, reliable, maintainable, and scalable.
Software engineering was supposed to go away when low-code/no-code hit the shelves. It was supposed to go away when WYSIWYG IDEs hit the shelves. And it didn't. And now, with AI coding agents, it's still the same. It lowers the barrier to entry. You can get started faster than ever. You can even build small personal projects and productivity tools with little or no SWE experience. But as soon as you want to build software in earnest, you need to know the fundamentals: Security, maintainability, scale, reliability, etc. They do not go away regardless of how advanced the software-building technology becomes.
25
24
4
290
13,240
Dang, Freddy’s crushing it on picking games for his college football tour.
I had no signal at all inside the stadium. THIS WAS THE BEST SPORTING EVENT I’VE EVER BEEN TO! We were sitting in the Oklahoma section, goosebumps throughout the entire 4th quarter!!!!
37
Kevin Smith retweeted
there's no such thing as a rogue agent man its software someone made and deployed they are responsible for what it does cannot let this blame shifting occur
150
434
41
4,700
95,131
Kevin Smith retweeted
Satya is right. The way to make SI safe is not to train it with a sense of self, its own moral philosophy, and permission to act as a conscientious objector. That’s the “alignment” approach and it magnifies the control problem. The engineering approach that Satya describes is different: separate the supply of intelligence from authority over it. Surround non-deterministic models with deterministic controls, observability, privilege limits, logging, and the ability to always contain or shut them down. Treat models/agents like powerful insider risks, not moral patients whose psychological wellbeing is at stake. As Satya points out, the most trustworthy system is the one that lets us trust the model the least — not the one that encourages the model to develop independent agency and grievances. Engineering safety is not the same thing as “alignment.”
683
950
180
8,524
611,978
This is what I don't get about the crowd that claims unit and integration tests are now some kind of anti-pattern. If you're only running e2e tests, how slow are your test suites?
This is like putting weak brakes on a sports car. Unit and integration tests report regressions *quickly*. E2E tests are too slow to cover all scenarios. I’ve seen teams try E2E only. Their tests ran for over an hour. To move fast safely, you need to be able to stop quickly.
1
58