Yes my hot take is that the real risk isn't skill atrophy... it's failing to develop the new skill of using AI. It's all abstraction layers anyway and people always lament the next abstraction up.
0/1s → assembly → C → high-level languages → frameworks → AI → product
The engineer keeps moving up the abstraction chain with less and less understanding of the layers below. The better solution would be creating better verification, testing, and determinism at the AI layer. Surely we'll see the equivalent of high-level languages and frameworks for AI soon.
I find “maintainable code” the hardest bias to let go of. 15+ years of coding and design patterns are hard to let go.
But the aha moment for me was what’s maintainable by AI vs by me by hand are on different realms. So maintainable has to evolve from good human design patterns to good AI patterns.
Specs are worth it IMO. Not because if I can spec, I could’ve coded anyway. But because I gain all the insight and capabilities of AI, while minimizing the gotchas and edge failures.
> But the aha moment for me was what’s maintainable by AI vs by me by hand are on different realms. So maintainable has to evolve from good human design patterns to good AI patterns.
How do you square that with the idea that all the code still has to be reviewed by humans? Yourself, and your coworkers
I picture like semi conductors; the 5nm process is so absurdly complex that operators can't just peek into the system easily. I imagine I'm just so used to hand crafting code that I can't imagine not being able to peek in.
So maybe it's that we won't be reviewing by hand anymore? I.e. it's LLMs all the way down. Trying to embrace that style of development lately as unnatural as it feels. We're obv not 100% there yet but Claude Opus is a significant step in that direction and they keep getting better and better.
Then who is responsible when (not if) that code does horrible things? We have humans to blame right now. I just don’t see it happening personally because liability and responsibility are too important
And you don’t blame humans anyways lol. Everywhere I’ve worked has had “blameless” postmortems. You don’t remove human review unless you have reasonable alternatives like high test coverage and other automated reviews.
> But the aha moment for me was what’s maintainable by AI vs by me by hand are on different realms
I don't find that LLMs are any more likely than humans to remember to update all of the places it wrote redundant functions. Generally far less likely, actually. So forgive me for treating this claim with a massive grain of salt.
I recently discovered GitHub speckit which separates planning/execution in stages: specify, plan, tasks, implement. Finding it aligns with the OP with the level of “focus” and “attention” this gets out of Claude Code.
Speckit is worth trying as it automates what is being described here, and with Opus 4.6 it's been a kind of BC/AD moment for me.
Welllll... I gave Opus 4.6 the repository and a sample .mono export and it nailed the file format. There's something to be said about tools and formats that are easy for human-AI end-to-end operation.
┌──────────────────────────────────────┐
│ New post hits Show HN: │
│ "MonoSketch — Draw ASCII Diagrams" │
└──────────────────────────────────────┘
│
│
╭───────────────▼──────────────╮
┌┤ Did you read the article? │─────┐
│╰──────────────────────────────╯ │
No│ Yes │
│ │
│ │
┌────────────▼───────────┐ ┌────────────▼───────────┐
│ Skip straight │ │ Hmm, this is │
│ to the comments │ │ actually kind of cool │
└────────────────────────┘ └────────────────────────┘
│ │
│ │
┌────────────▼───────────┐ ┌────────────▼───────────┐
│ Adopt the hottest │ │ Could I build this │
│ take as your own │ │ myself in a weekend? │
└────────────────────────┘ └────────────────────────┘
│ │ │
│ │ (alway│ yes)
┌──┘ └────┐ │
┌───────▼──────┐ ┌───────▼──────┐ │
│ "Just use │ │"I built this │ ┌────────────▼───────────┐
│ Vim + sed" │ │ in 1997" │ │ Start rewriting │
└──────────────┘ └──────────────┘ │ it in Rust, obviously │
│ │ └────────────────────────┘
│ │ │
└───────┬─────────┘ │
┌────────────▼───────────┐ ┌────────────▼───────────┐
│ Post with mass │ │ Abandon project after │
│ confidence │ │ exactly 2 hours │
└────────────────────────┘ └────────────────────────┘
│ │
│ │
│ ┌────────────▼───────────┐
│ │ Star the repo on │
│ │ GitHub anyway │
│ └────────────────────────┘
│ │
│ │
└────────────────┬────────────────────┘
┌────────────────────────▼───────────────────────┐
│ Refresh HN every 45 minutes │
│ to check your comment karma │
└────────────────────────────────────────────────┘
│
│
┏━━━━━━━━━━━━━━━━━━━━━━━━▼━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Repeat tomorrow with a ┃
┃ completely different tool ┃
┃ ┃
┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
Alternatively, another second order effect is can't sip latte anymore because you're orchestrating 8 bots do the work and you're back to 80%-100% time saturation.
So far in my career I have always had more requests coming in than implementations going out. If I can go 3 or 10 times faster, than I will still have plenty of work. Especially for the slew of ideas that are never even considered to put towards a dev, because it's already considered to be too low value to have it even be considered to be build. Or the ideas that are so far fetched they were never considered feasible. I am not worried work will dry up.
What I believe is going to be interesting is what happens when non-engineers adopt building with agentic AI. Maybe 70 or 80% of their needs will be met without anyone else directly involved. My suspicion is that it will just create more work: making those generated apps work in a trustworthy manner, giving the agents more access to build context and make decisions, turning those one off generated apps into something maintainable, etc.
Would be curious about this too. It’s a mental shift to go from understanding everything about the code, to trusting someone else understands everything and we just make decisions.
I wonder if you could train an LLM with everything up to Einstein. Then see if with thought experiments + mathematics you could arrive at general relativity.
The problem is that the 'genius' of Einstein wasn't just synthesizing existing data,but actively rejecting the axioms of that data. The 1875 corpus overwhelmingly 'proves' absolute time and the luminiferous aether. A model optimizing for the most probable continuation will converge on that consensus.
To get Relativity, the model needs to realize the training data isn't just incomplete, but fundamentally wrong. That requires abductive reasoning (the spark of genius) to jump out of the local minimum. Without that AGI-level spark, a 'pure knowledge pile' will just generate a very eloquent, mathematically rigorous defense of Newtonian physics.
When I hear people complaining about this sort of thing, I want to say, “Just go and invent your own, then.”
But then you get things like Esperanto. Esperanto takes about 1/4 of the time to learn compared to other languages. It’s taught in China and used as primary language in some settings. But, aside from a large number of people learning some Esperanto from Duolingo several years ago, it’s just another language now to have to learn.
0/1s → assembly → C → high-level languages → frameworks → AI → product
The engineer keeps moving up the abstraction chain with less and less understanding of the layers below. The better solution would be creating better verification, testing, and determinism at the AI layer. Surely we'll see the equivalent of high-level languages and frameworks for AI soon.
reply