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.
To understand and empathize with how workers in many or most fields outside software experience advances in AI capabilities, I propose a little thought experiment. https://t.co/QZG24aRiBe
🎙️ 🚨 Latest State of Agentic Coding w/ special guest @mariozechner (Flask) is out:
- Vibe-checking Fable & GLM 5.2
- @mitsuhiko teaches us RL
- How harnesses smooth out model jank
- Loops, surviving AI fomo, and more
Also on YT & Spotify ⬇️
I know that AI makes me more productive yet at the same time I have very little success in speeding up the thinking part. Example from the last two days is just to come up with ways to map some of the upstream provider functionality to Pi.
It took me no time at all to slop something up that ended up with pulling all that complexity in. On the other hand providing an abstraction that works across all of them is still tricky and I feel like I'm about as fast as before, except for the parts where Pi helps me build POCs and probe APIs.
At least for what we're doing right now the easy parts got even easier and the hard parts didn't move nearly as much. Except you can turn your brain off, and pretend the hard parts are easy parts then you're good to go. But then you have slop.
Thank you for reading this rant.
cosign. I don't find the "create giant spec and let it loose overnight" very productive. I need to be in the loop to even know what I want. The majority of the finished product is in the iteration, not v1.
Being part of a generation that was told “Wikipedia is not a source” makes it genuinely baffling to me that jobs are now telling people to just use ChatGPT for everything.
As the family IT guy its so disappointing how bad of an experience technology is for non-technical people.
I had the distinct pleasure of building educational software for kids full time for a summer while in college (s/o to @WilliamsonMark), and I remember they did weekly/biweekly user testing where a group of toddlers would come in and we'd record them using the software in various states and then adjust accordingly.
Every single session was SHOCKINGLY illuminating. Like, I expected after a number of these I'd empathize more and build better toddler software one-shot right? Hell fucking no. Every user study was so educational. I learned I simply can't enter the mind of a toddler.
Do TV companies, Netflix/Roku/etc. do user studies with elderly people? Do they realize how dogshit and impossible to navigate their interfaces are?
Asking some elderly family members to "sign up and schedule an Uber to pick you up for the airport" is like mission impossible. I thought they were exaggerating, then I tried the experience and holy shit man. Try cold finding, installing, signing up, and scheduling an Uber on a 5 year old iPhone with max font size. Its insane.
You might believe you should spend less time thinking about code because of AI.
I strongly disagree! We’re watching this play out live where tons of AI generated code becomes a liability.
At the end of the day, an engineer needs to be responsible / on call for code that gets shipped to production. If you don’t understand the system you’re trying to debug, you’re probably going to have a bad time.
Yes, AI can help with all of this, if you set up the proper systems. You can have agents triage prod logs, look at errors, etc. You can speed up parts of the investigation, but an engineer needs to make the call. There might be serious customer or financial implications from that change.
I expect the trend continue for trimming dependencies, vendoring code so you can modify it directly, preferring simpler systems with fewer abstractions, and spending waaaay more time thinking about system design and code maintenance.
I’ve said this before, but it’s a great time to get familiar with CS fundamentals and some of the history behind what great software looks like. Many parts will be different in the coming years as AI progresses, but also a lot more than people realize will stay the same.
It’s 2018 and your coworker just sent you a 400 line pull request.
You get a cup of coffee and sit down to review it.
It’s beautiful. Elegant micro-refactors. Crispy method names.
You catch a few things, but that’s ok. It’s part of the dance. They didn’t consider extensibility on part of their API. Here’s a comment buddy.
They respond in an hour saying they think we should do one piece differently than your comment. Hey let’s jump into a room and figure it out. We can’t just agree to disagree, this code is too important.
The PR merges and goes to prod. You feel a shared sense of ownership and accomplishment.
That night you go to sleep and dream of that code. You can still see the shapes of it on the backs of your eyelids, your IDE syntax highlighting sparking neurons in your reptile brain.
You go to work the next day ready to go. You understand the system. N is your foundation. Time to build n+1.
you can vibe code all of it
who cares
lie to yourself
pretend it's a clever strategy
but everyone will know
they can feel it in your work
how lazy you've become
how little you care
because how you do one thing
is how you do everything
The "you're falling behind on AI" crowd is weird. The whole point of this tech is that things get 10x easier, not harder.
Complicated agent/prompting patterns get replaced by better models, simpler patterns, and plug-and-play tools. Catching up takes a day, not months.
I'll continue to die on the hill of "magic directives are bad API interfaces". They're not type-safe, they're not extensible, no native runtime control, they're just strings.
... I can't believe I'm saying this, but I would rather debate @ directives. Pls rewind history.