If you stop writing code, you also get worse at reviewing it
cekrem.github.ioIt works to supplant/eliminate those who produce the quality data (aka well written code) it needs for training.
AI trained on AI slop can only get sloppier over time.
Those designing for human comprehension, simplicity and maintainability are less likely to be the ones dumping their code-base into a model. When actively hostile to AI, they will be less likely to even open-source their projects. Maybe there is a future for restricted openness with circles of trusted human collaborators.
However, the users with piles of faulty dog-shit they don't understand or care to even try, will be the whales. The perfect customers, utterly dependent and burning tokens every day for trivia.
How long until the companies intentionally farm such dependency e.g. gently obfuscating code output? There is a dystopic future for regulated full lock-in where only binaries are sent to the client not code, model-hopping is blocked with legally mandated decompilation guardrails and secure-compute hardware that refuses to run open models.
1. Anything that’s boring to write - aka I’m not learning, done it before, I can quickly review - I offload to agents. And still review entirely since it’s my reputation behind it, but I’ve found it to be relatively pain free to review.
2. Anything that I don’t know what it’s gonna look like, I do my normal planning but with a lot of agent review involved up front. At the end of this, I more or less know the code that’s gonna be written and thus don’t type it myself. I still do line by line review and spend a lot of time on things I don’t understand. It still feels like the same process (wrt understanding) when I had typed and then reviewed what I typed.
I still (from what I can tell) have the same mental model I did when I hand typed the code, even though for the most part I’m not. I am worried if I’m losing something, but so far it seems ok. It’s also certainly not a 10x speedup.
Unless you have uncommonly clear-headed management, you will likely feel pressured to increase your speed, since it's so much easier to judge output volume and delivery speed than the ephemeral "quality" that you add by thorough review and understanding. Having already adopted the tooling, and especially having seen it successfully churn out the boring parts, it will become easier and easier to justify offloading the review of those parts. Then a few weeks later, some of the trickier parts become boring, and you rinse and repeat until your only remaining job function is to take the blame when the code nobody has read blows up.
Not saying this is inevitable, just incredibly common. So even if you are personally able to hold the line, you should expect to be increasingly surrounded by colleagues who have gone all in.
1: https://dustycloud.org/blog/faulty-towers-vibe-sickness-and-...
On the other hand, infinite backlogs, crazy tech debt and understaffed dev teams mean a lot of the times off loading more work to agents with less human review will lead to better results on average.
"The pen is a virgin; the printing press is a whore."
For a long time in coding, we've constantly been piling on technical debt, even before AI. With frameworks, layers, etc. But AI is a quantum leap that makes the problem far worse.
Note that compilers that go from C to assembly/machine code are a lot different because C for instance (or Rust, Python), etc. still exposes all of the core abstracted logic. AI does not. It hides the logic.
In the future, no one is going to understand much of anything except a few who will command vast AI infrastructures that will just attack each other, because the attack surface will just have multiplied to a point that bringing other people down is far more lucrative than doing anything else.
It's all so obvious and yet we continue on.... a sad state of affairs for programming. AI is a bad thing indeed....
Back in the 90s, places that hired 3D modelers/animators would say something like "Look, we don't care if you know the program. We can teach you that. What we want to know is can you draw?" There's a base level understanding required for any higher-level endeavor. I would not expect a person who might even be considered an expert Python programmer to immediately be ready to become a core maintainer for the kernel. If you don't do the low-level stuff, early and often, you won't recognize the foot-gun when you see it.
Maybe the LLMs will get so good that isn't a problem? Okay, sure, possibly. If it gets to that point before all the greybeards retire or die, then it's possible we can dodge what I see is a negative feedback loop. If not, then I think the future is much less rosy.
And yeah, I’m not sure how that goes away either - life is full of tradeoffs, how do you RL things with no objective truth?
It was pretty good, understood what I wanted to do, and broke it up in playbooks/roles/etc. quite well. But then it did things like continuously overwrite the LetsEncrypt cert for each domain with the next one in a loop. It understood "this needs to be a loop" and how to optimize that loop, but not that it was going to overwrite each domain's key with the next.
I'm a pretty good sysadmin, so I recognized this and could take what it did and fix it, but it required a deeper understanding of the underside of nginx/LetsEncrypt and the filesystem to even see what it was doing.
Of course, once you run the playbook, test a domain and see its SSL cert is all jacked up you'll go looking for WTF happened, but just blindly taking the output as given meant it was horribly broken.
It may be that Ansible, by its nature, is a bit sui generis because it touches so many unconnected domains, and therefore is harder than outputting Python. I don't know. But one needs more than a surface level understanding of those domains if you want to catch the LLM being stupid.
There's so much to learn in the world. The domain knowledge I used to carry about software, I hope I forget most of it. I hope I learn things that let me do things I never could've conceived of before.
LLMs emitting code are a great workaround for "bury the complexity, I just need the result" and terrible for "this codebase produces long-term value". People are slow to learn the difference, and the AI gold rush profits from the confusion. We thought television would bring Shakespeare to the masses. It didn't, but theater was still there for Patrick Stewart (RIP). Software engineering will be okay.
I'm not at all convinced that LLMs will kill software engineering but I'm equally unconvinced that it will be an overall positive for innovation in the field, at least while we're basically all running things through the same handful of closed model orgs. It's just a really weird time where I can't decide if I'd rather jump back and work in the world of five years ago or take my chances and jump forward the same period.
It just doesn't work this way. The industry develops and we adapt. I might not like it, but it is how it is.
Reviewing code and writing code a different skills. They are related, but they are very different.
Someone who can imagine and type up good solutions, can review the work of others.
IME good reviewers may be a bit better about being gracious with minor differences in opinion/style and managing emotions and politics of everyone involved.
Being a good reviewer takes reps and practice just like writing.
The thing I really miss is the flow state. That is elusive for me so far. I can’t even listen to my coding music. I need silence.
But a good bit of software dev was taking the time to go through documentation to understand specific syntax or what was possible with a certain type of tooling. I’m okay with automating the mundane and having much better software using the latest infrastructure and libraries. This all comes with tradeoffs, but I just don’t buy the “autopilot” argument. I’ve learned more in the past year than any year prior in technology. All this learning is now possible, because I’m not spending my time wiring a react front end to a backend for a simple table crud operation.
This makes no sense to me. If something needs doing, it takes the time it needs to.
> because I’m not spending my time wiring a react front end to a backend for a simple table crud operation
This also makes no sense to me. Either this crud aint simple, or you’ve invested nothing in automating it.
Triage comes from war hospitals, where the number of people would and needing treatment would often outnumber the staff. Those people need treatment, but the staff didn't have time to attend to them, and so many died.
Adding technologies often reduces the time or takes to do a thing, allowing you to do more things overall. For example, if you seal a wound with super glue instead of stitches you save time, and more people as a result. (And yes, that was the original use case for super glue!)
AI assistance is letting us find and fix bugs that we previously didn't have time to discover or to fix. And a million other things that were previously outside our time budget.
I get that AI lets you do certain things faster, but we’ve been code generating our way through crud for many years now through django, rails or api schema -> typescript.
If adding crud operations take so much time that you can’t focus on bugs, you’re mostly dealing with bad management.
I was hoping that, for every “write X for the Nth” time we would get better tools to obviate that need, only needing to do it one time. The reality is a million times more disappointing.
For example, I've been around make files for over a decade, I can read them fairly fluently, but if you asked me to write one from scratch, I would be chained to the docs.
Another example, I can read Spanish to the level of understanding the gist, but I'll lock up if I need to speak more than a sentence or two.
With the agents, you can have it generate it, and you'll understand it on a cursory glance, but you won't actually know it. IMO the difference between knowing something, and understanding is whether you can bring it into existence with minimal outside reference.
With LLMs you feel like you're learning a lot, but you lose out on the hard part that actually commits it to memory.
To be fair, on the flip side I've written enough basic xxd style debug print functions that I know I don't want to do it again.
To fix and debug things, you need a better understanding than you do to introduce the bugs in the first place.
Agreed. Under your POV, I'd say "knowing" is equivalent to "memory recall of many relevant facts" (aka, "memorize a bunch of stuff").
Whereas Understanding, by my definition, is: having a rich mental model that empowers the thinker to make true conclusions/hypotheses that are not explicitly stated elsewhere (e.g., not in the 'knowledge list'). The too-rarely-used-these-days term "to reason about" seems to be about having such a model for the domain in question.
And with LLM-centric workflows our ability to reason about the system is fading. No bueno.
I was still never able to write it, even after I had Claude create it.
If "writing code" is a craft then not writing it would result badly reading it, true. But I disagree that software engineering is a "writing code craft", it contains much more (designing system, architecture, testing, requirements and spec design, etc.) so all these things stayed with AI agents writing the code, and also software engineering craft expanded with new workflows and kinds of problems with AI. So getting worse at reviewing the code might be somewhat expected outcome in that change, we'll see over time
There are a lot of skills that are no longer important to software engineering like the specific lines of code that you write, but building software that is maintainable and delivers value to its users involve many many more skills than LLMs can deliver right now.
If you want to stay relevant in the field, there is no way forward other than embracing the torrent of LLM tools, news, releases, and figuring out how to shape that into your process in a reliable and responsible way.
1. It was good for collaboration. Sharing how you are changing the codebase pushes everyone to row in the same direction, and provides a sense of team ownership.
2. It was good as a push for engineers to take pride in their work. Knowing someone is watching gives you subconsciously an extra reason to not cut corners. And when you spend effort not cutting corners you expect that in your teammates, which is a (potentially) virtuous circle.
3. It was good for catching mistakes. When code was expensive this was important.
Everyone thinks of code review as primarily relevant for 3, and since code is no longer expensive they think it is unimportant and you can skip it. But 3 isn't dead, its importance has just shifted from code to architecture. It is still an expensive mistake to screw up architecture and have other engineers build upon that flaw. Re-architecting with live users, data and/or hardware is not as simple as fixing a code bug, and it deserves attention to catch mistakes. Collaboration & pride are also still important.
This is the reason that instead of stopping review, we need to change what abstraction we review. Code is no longer the right tool for understanding applications in most cases.
(disclosure I work in this space and run https://www.archme.io which is working to solve the above)
I like your ArchitechMe approach because it operates at what is left. The Software Engineers still need to "work on the system, not in the system". Before those folks were in the code, but with so much being written now we need better tools like you ArchitechMe to make sure the system is operating like we want it to.
The problem right now (and why teams are shrinking) is because people haven't figured out how to collaborate at scale with AI IMO, so they just give up and say it's easier to manage a small team of seniors.
It's almost has hard to have agents write the code and review every line than it is to write it yourself IMO. So either they write and your review and you get a 10-20% bump, or vibe engineer and get a 200% bump.
I'm attempting to build a way to avoid looking at code, while still being able to engineer because frankly it's hard to engineer without looking at a shared artifact. Anthropic et al want us to just stop engineering and let agents take over, I think we should be empowering humans to work at the correct level with the agents instead.
What are we bumping 200% exactly, the PR rate? What about the bug rate, and volume?
I also lose context and understanding of my app far faster, as I'm not spending as much time on individual features, or working on code.
It may surprise you but code review is actually something you need to automate with deterministic software.
For some reason people don't seem to understand what a developer's job is.
Automating code review sounded asinine two years ago because the cost of managing the automated process exceeded the cost of manual reviews. Aka it was pointless busy work.
But now that we have potentially adversarial agents, it is kind of essential.
I think especially in a world with provably correct code, you want to primarily focus on determining and building the architecture.
The best parallel I can think of is, whenever I design databases with lots of tables and relationships, I keep a nicely organized MySql Workbench flowchart to go along with them and review. It's good to have that higher level abstraction as a map. The thing is, implementation details still matter. Bad triggers or foreign keys lead to deadlocks. So if you're a dev and you're looking at this flowchart as the map of your codebase, you may still not familiar with the actual code, and I think that's a liability.
>> When code was expensive
You're dead right when you say re-architecting with live users is harder than fixing a code bug. But poor code implementation can masquerade as something that fits within your architecture until it's too late. The 7th example on your website shows someone trying to fix a bad implementation: This card renders before POST is completed, what rolls it back if POST fails? That's like a kablooey. I bet that's not a one-off problem. Even though your architecture looks good in the flowchart, everything about how it's handling server calls is wrong. The wrong tools or methods were chosen to implement it.
This is where not reading the code as it's written can give the illusion that things are alright, when really there are broken states and you'll need to rebuild fundamental systems from the ground up... systems that you don't really understand now, because you didn't read the code in the first place.
When people say "code is cheap now" the idea is, no big deal, we can just ask the LLM to do that when it crops up. The thing is, "code is cheap" is like "talk is cheap". It's not cheap when you specify something vaguely and the misunderstanding leads to a catastrophic result. E.g. talk isn't cheap when the president is ordering an airstrike on the wrong target. "Yup, that looks like a mountain in Afghanistan" isn't sufficient. Precision in language matters in life, even for small things, because you want to make sure everything is understood and implemented correctly. And you can't know if it was implemented correctly if you're not reading the actual code.
When I order at the drive through, even though it shows me on the screen what I asked for, I still check the bag before I drive away. But if I had no idea what the contents of the bag were supposed to look like, because my ability to distinguish french fries from nuggets had atrophied, if I just peeked inside and went "oh, looks alright," then at some point I'm going to end up with the wrong order. That's no big deal if I'm just ordering for myself, but what if I'm ordering for 50 people?
I don't know. Sorry for the rant. I think what you're building looks like a nice tool, and I'd like to experiment with it, although I'd really only want to use it offline. But I don't know whether it would fix the atrophy problem or aggravate it.
I'm trying to convince the people that don't look at code at all anymore that review is still important, and that the way to do it without losing the efficiency gains is at a higher level with a new abstraction to look at. Without that everyone's understanding of the app drifts in different directions and collaboration becomes difficult.
Also we offer 3 ways to run the project:
1. you connect your git repo, we run the scan and updates for you on each commit 2. your run the scans and updates yourself on each commit through our npm package, but your still use our UI and DBs. 3. on-prem, "offline." You'd need to contact us first, but I'd be happy to help out. Just reach out and mention you came from HN.
Then again, pilots are mandated to fly manual specific number of hours even though autopilot is a thing.
You know, just in case. Same should be applied here if one is on the cautious side.
There are a few problems though. The biggest is there simply won’t be a mandate. Flying is a really regulated industry and (compared to software) has a defined set of parameters - at least from a training point of view. Translating that into software would be difficult.
While thats kind of a joke, I think there are developers who learned to code by reading (review) existing code. Maybe this will have to evolve for the age we're in.
The job of the software engineer is to interface with the world, create a mental model of that world, and then make software that matches. That hasn't changed. We are still figuring out what the new best practices are given there are less people to align.
It's not the same job, and you don't have to have been a musician to do the job, but having been a musician, you have an insight into the music-making process that can help you be better at producing other people's music.
Taking that analogy further, there are some fantastic producers who are terrible musicians. Perhaps that's the bigger worry, you don't need to be good at writing code to be able to produce it any more.
Five years ago it was common knowledge on HN that moving away from the code (like taking a management position) atrophied your programming skills. The routine suggestion was to get your hands dirty again.
AI-first folks will tell me I should see my new responsibility as being just such a manager over little agent kiddos running around. However I can turn a flesh-and-blood Junior/Intern developer into full independent developer I can trust with more complex tasks. I can't do that with AI.
I previously made the observation [0] that the AI talk mirrors the Outsourcing talk from the early 2000s. I have a terrible feeling we are going to learn these bitter lessons all over again.
This has the potential to mitigate some of the atrophy that is well documented in management positions and perhaps for someone in such a position (be it managing people or AI) to review code better than they otherwise would.
The recurring problem I see is that we have been given immense power but abdicated responsibility. That is understandable, given the marketing and packaging kf the tools as "agents" that do tasks end to end.
Reality is that you need like one or more specialists in devops (mlops? I think that's a thing) to implement a reliable pipeline. The parallel agent model has never worked for me, because I am a careful reviewer
https://www.reddit.com/r/ClaudeCode/comments/1y0yquc/they_pu...
Apologies for raw reddit link, old.reddit.com dead and I can't recall the thing to use now
This means we must be just as skilled as before AND manage these other inputs AND take responsibility for the overall deliverable. No wonder developers are burning out.
There is literally decades of research into this at all levels of education. You absolutely "lose" skills that you don't practice and reading documentation is not the same skill as writing/reviewing code. Active learning vs passive learning.
It's the reason "note taking" was invented and we don't just sit there and listen to lectures.
It's pretty shocking how many supposedly smart people are just forgetting very basic things that are literally things you learn in middle school.
Really the goal is to have these models completely replace software engineers altogether. Skill atrophy isn't a concern when you don't employee devs whose skills need to be prevented from atrophying. A lot of devs also can't draw this obvious conclusion.
It's weird feeling like the odd man out with these two conclusions on the matter. But software devs are stuck in the fantasy of "this makes me a 1000x engineer and it's a tool that works for me, for my benefit". Which, sure, when you use it as a research tool, I can agree. Agentic code generation, if it doesn't outright replace engineers, will be seen as the tiktokification of programming, and its effects will become obvious, hopefully in the not-too-distant future.
But that makes LLM speedup like 1.5x the manual-typing coding speed, vs 50-100x you can get if you vibe all the way.
I still use LLMs for troubleshooting, searching, codebase knowledge gathering, solution exploration, writing tests and documentation and whole-codebase changes and there the speedup is dramatic. However I don't feel I become a better developer for doing these kind of tasks without LLMs.
For documentation and tests though I feel I am slipping on reviewing the output because it is just so boring that I often "surrender" the task to the LLM which generates bloated tests and bloated docs.
This is the best I came with so far, but I have to admit how slow my main projects move, if at all.
If you have a robust ticketing solution at your org just use it. Theres probably a baked in MCP. At work I use(d) JIRA (laid off, hmu w bay area or remote work), at home github issues are fine to a point then I use vikunja or openproject depending on the box its gonna live on.
If I was Junior in 2026 I would be breaking down work into the smallest components possible so that my understanding of the work was scoped and more importantly the inevitable AI sprawl would be similarly scoped (and easier to rein in/call out).
If you don't know how to break the work down ask for help. I wish I asked for help more earlier in my career.
As for the last part about bloat, I've started tinkering with prompts that attempt to minimize generated code output. I'd wager that having agents take a second or third pass to "prune" the output of the former would work too.
Yes, you're right. Moving away from the code would atrophy your programming skills, sort of, but if you're still involved with the code on a day-to-day basis, then you're not moving away from the code.
> AI-first folks will tell me I should see my new responsibility as being just such a manager over little agent kiddos running around
Yeah, I've never heard someone talk about it like that, but I'll assume that you have and just say that whoever you're listening to is nobody that knows what they're talking about. I've never seen anyone describe it like that, and you can safely not listen to them.
Which means if you're getting your information from people like that, you probably are very much misinformed, because I wouldn't trust anyone who said something like that to properly inform me.
The important thing to realize is: is somebody moving away from code and moving to non-code things, like a management position, or are they still involving themselves day to day with the code and just working with the code differently? And the disinformation that you've been fed seems to have polluted your way of thinking. I would go back and review where you got this information because, again, it's not a trustworthy source if they're talking about kiddos.
We're in the twilight zone, AI ain't there yet, neither are developers.
> where the Best Practices seemingly flipped
There will be new BPs when AI becomes real - for now it's enough to make sure open source AI gets there first.
> the AI talk mirrors the Outsourcing talk from the early 2000s. I have a terrible feeling we are going to learn these bitter lessons all over again.
Because of this and a lot more.
Why not? Over the past 20 years I've worked with some incredibly smart and accomplished engineers, some of whom have single-handedly built complex products and services used by millions. And today none of them would come anywhere close to what frontier models are capable of.
Curious...
- You can't write code as fast or "good enough" as AI.
- Not writing code quickly atrophies your ability to do anything code related.
It seems to me like a giant bet on AI being able to replace software devs (and soon - other professions). And you're forced to participate in that bet if you want to stay a software dev.
To some extent, you can: better doc and better support scripts (linters, tests, infra as code, etc) do not replace a human being but it goes a long way toward improving your coding agent. Especially since many of those ad-hoc scripts wouldn't even have been written by hand in the first place. The cost/benefit ratio changes.
it's just a lot of noise i tune out, even when using AI i'm interested in fundamental things that are known to work and using patterns that are understood so i can pick through a codebase and see what it built. i'm a little tired of all the AI black box projects that come to be because the scope is way too grand
Before agentic development, the cost was large for changes at the review stage. Often the person writing the code didn't have the right context or experience to make the best choice. So reviewing would often blow up a pull request. Which sucked. Eventually every engineer would have AI generate a PR. People would review, blow it up, and the engineer would copy/paste the feedback into AI to generate another PR.
But now, we use reviews to enforce design decisions and get feedback from the other people who couldn't be involved in the initial design (for example if a new feature interacts with a module owned by another team).
The actual nuts-and-bolts of how the code is written is mostly unimportant. It was a large mentality shift for the company
We spend LOTS of time on the design, verification, testing. The verification and testing is built first. Agents take the input of the problem, design document, and current codebase to generate code. It iterates by running the verification tools. Then it runs the testing tools.
The better we make the tools for AI, the better the product code is. We've automated gathering power readings, timing reports, wifi/ble sniffing, smoke tests, feature tests, corner cases, robots for pressing buttons, static analysis tools, unit tests, customer styled system tests... tools to emulate cell phones, servers, etc...
I am struggling to come to terms with this personally. I was someone who really tried hard to make sure the nuts and bolts was good quality. Kept on top of language features, made sure not to use deprecated APIs that could expose security problems, etc
It wasn't just "to make the code more maintainable" or anything, those choices mattered, or felt like they did
Now it feels like everyone is saying "those choices don't matter, and never did"
Have I just been wasting my time and focusing on the wrong stuff for my whole career?
I'm going to ignore the using an actually broken API, and instead think about using a sub-optimal one.
Before, you tried hard to get it right first time, because it was a pain to change if it wasn't.
Now, that change is much, much easier. A task like "rip out this deprecated package and replace with a new one" used to be a LOT of effort but, if we're honest, not an awful lot of skill. Now its quick and easy.
Making the right product choices, or architectural decisions remains just as important, because they're still an absolute nightmare to change later, but the nuts and bolts much less so.
One thing I am still seeing is we STILL can't admit when we're wrong. We refuse to believe that we cannot think of everything before the code gets into production.
Really it's some core teams who do not have a 'sustaining' budget. They call themselves Services R&D.
For example they made a messaging stack with encryption, serialization, addressing, routing, etc. But it has a huge flaw in that there is a maximum packet size. The design is such that an app cannot implement chunking on top of the messaging. So there is no way to transmit data greater than the packet size or do any kind of data streaming. THere are 3 products now who are mandated to use this messaging stack but can't fit into the packets
It seems like a culture of 'deliver and move on' rather than 'deliver, support, improve'. Not sure how to fix this problem
Think of assembler vs compilers for higher abstraction level languages. When you write in C or Python you trust the compiler to do the right thing and don't routinely review generated assembly let alone machine code.
It's the same here. You write your program in natural language and have the compiler (ai) make it happen. This is what it will converge eventually to.
I kind of do now, but in the AI era the maxim that code is not precious has not been more applicable until now.
Have I just been wasting my time and focusing on the wrong stuff for my whole career?
It used to matter and for that time it was appropriate, but going forward it isn't that relevant.
sure, this is short-term because you still have people around who wrote (most of) the code and understand it
once you no longer have a good understanding of the codebase, you also don't know what to test and validate
AI is great at writing tons of tests; whether they're the _right_ tests is another question
Note that I don't particularly enjoy this, more like realizing what's hapenning at my scope.
So personally I have been fighting this by going all in with personal/side/shadow projects whenever I find the time, and adjusting my manual coding in them as I see fit
instead, i give them worse code i get for free (uhh well they pay the thousands of dollars for the tokens)
so i get to work less and build more stuff i actually own
Human programming is basically a zombie roaming the streets completely unaware that its dead.
But then people forget you can still "get rusty" from not playing chess in a while.
Yes, a guitar player should not expect to just stop playing guitar because they're good enough but equally... a composer does not need to be able to play each of the instruments they compose for.
They're collapsing the role ("software engineering") and an action ("writing code") into the same thing. Some roles do lend themselves to this (guitar player!). some do not.
there won't be anyone with technical knowledge to manage the agents; it'll truly be a black box
For example, yesterday it appeared that some AI changes made a regression. I spent more time going back and forth, trying to "fix" the regression, than the initial prompt. It took traditional problem solving skills to figure out that the regression happened before AI's changes, and how to reproduce the regression.
The most important property of "code" is the code architecture, not the LOCs themselves -- i.e., the functional contracts, interfaces, and coupling between them.
That's what really dictates the ability to manage correctness of the system, its testability, and refactor it into new capabilities going forward.
But code review cultures -- ime -- always focused on the lines of code... "you could make these three lines into one", etc - stuff of interest but not worth the code review time over more important considerations.
AI agents are so good at writing tests, if you can prompt and guide them to good code architecture, it seems to me so much of the game is won w/o needing line by line code reviews.
We both do rock climbing and gymnastics, and one day, while we were climbing, this person approached my friend (who is a great climber, and newcomer into gymnastics) and asked:
- "Hey Dude, I noticed you're now doing gymnastics! That's sick! Do you find it helps with climbing?! You must be a lot better now because of it eh!".
My friend then responded pretty seriously and blunt:
- "No. More climbing helps with climbing."
I still laugh about it every time I remember it.
Anyways, all this to say that I think it's quite obvious that you need to practice the thing to do the thing and only doing the thing is doing the thing. [1]
[1] https://strangestloop.io/essays/things-that-arent-doing-the-...
> But if we can at least agree that the code that runs our software is a non-trivial part of...
This is just extrapolation from someone in a specific domain. For a majority of tasks, this is secondary. Output is primary. It doesn't matter how the code looks like, or how it runs, or what bugs there are. If people use the product and it provides some sort of value, that is enough.
1. If a person can devise a method of using AI for generating code why can they not devise automated methods of reliably verifying code?
2. I guess we can create a new job title of professional code reviewer - but without that I don't know how teams would keep up with the volume of code review when someone can open 10-100 PRs per day.
3. Do we believe human are good at code review, generally? I do not. When AI or other automated approaches are compared to humans reviewing code it seems like the comparison is towards this idealized amazing accurate human code reviewer but in our experience - such people exist - but they are far outnumbered by careless code reviewers.
Probably obvious from my comments - but I'm not planning to read much code anymore in my career. Seems like a waste of time when it can be generated and verified (adequately) through various automations. I understand that good verification doubles or triples the time of generating code - still way way faster than people being directly involved.
people are still just coping.
I personally hate code reviews and don't do well at it. But, I'm arguably really good at writing clean code that works well and is easy to maintain for the long haul.
I used to have a guy that worked for me that was on the lower end when it came to how he wrote code. But, he was absolutely great at code review.
With AI, I'm finding some of our engineers seem to be much better at code review and adapt their AI interactions accordingly. Namely, they do bigger chunks. Those who aren't as good tend to prefer much smaller chunks.
Interestingly, we had a project get out of hand with AI slop and I did an AI write moratorium. They could use AI to grok the code, develop ideas, and generate small code snippets they could then copy into the app's files, develop them further, and wire everything in. Importantly, AI could not write to any file directly. Obviously, this can be gamed, but they were open to trying it and it worked wonders for that project.
I suggested trying that for our entire org and I had one of my very good high quality engineers, who seems to be good at reviewing code, strongly object to it (with some good reasoning).
There is nothing else to learn, nothing else to appreciate, and nothing else to review
For us, it's so core to our nature that when some new tech promises all 3 in one, most of us can't help but dive in full steam and not question it.
The fact that Anthropic can so easily go around to tech companies and sell them on "coding has been solved," and "we just throw more AI at the issues our AI creates" without anyone normally skeptical of marketing is the wildest most surreal experience I've had on the ground floor.
There are actual engineers, people who went to university, who now equate prompting as just a new higher-level programming language and the code it poops out as the "new assembly language."
Normally organizations depend on their super senior engineers (a particularly powerful minority of folks that were promoted because they figured out how to scale themselves) to help guide decisions, but they're the ones most empowered by this shift because it unlocks even more scale for them. The juniors feel empowered because they can take on projects usually reserved for senior engineers and actually deliver on it. Everyone else is just caught in the middle, neither helped nor hurt by the shift, but also mostly fine if we rolled back most of this.
This is the first time I've seen something so pervasive, mentally break people, to the point we now seem okay with turning core IP into black boxes.
I agree the long-term effects of AI are seriously worrying, but what these models can produce is truly mind-blowing. I can’t say for certain that “coding is solved”. But I sure as hell can’t say it isn’t.
It feels like we’re close to a tipping point where generating code matters less than being able to clearly articulate an idea in natural language and knowing how to validate it.
Every layer of the stack has had decades of eyeballs, research, and actual validation.
Binary machine circuits, run by assembly that has been hand refined from LLVM (and GNU, etc.), generated from higher level languages that have been through so many brilliant engineers over decades that made conscious decisions how their language gets turned into assembly.
I don't need to know what Intel or Apple Silicon circuits do with the C++ or Swift code I write. As an engineer I entrust that these corporations employee other engineers who connect those dots, so that I can focus on C++ or Swift.
Natural Language (already imprecise and clunky) that non-deterministically spits out high level code works because every layer below it is doing the right thing. People love getting LLMs to generate rust because rustc is so crazy strict that LLMs can't cheat.
English on the other hand, every word can have so many meanings and developers who use LLMs to generate things they aren't familiar with, judge models based solely on whether these things can properly capture intent. It's one thing to say we can finally break free of dealing with shoddy, imprecise code, but it's another to say natural language is code.
Interesting that reading code seemingly doesn't have the same effect on writing it, according to this author at least.
There is a difference between building a thing, maintaining a thing, and understanding a thing. You don't have to do any of the one to be able to do the other.
I have 30 years professional experience, and 40 years total experience in software engineering. I started with assembler, then to C, then moved on to work in almost every popular language there is.
Last year I started working with AI. I've now gotten to the point where I can build huge, complex systems that would have been an impossibility for a single person before (short of investing decades into it). It's truly an amazing lever.
And then I did a live coding interview today. You know the drill: pick a language, talk about some problem that involves some kind of vaguely tricky algorithm you need to figure out, then code it.
Well, coming up with the algorithm, discussing the tradeoffs in time and space complexity was no problem, but then when I went to code it, I felt a very familiar feeling.
I still remember back in the day when I had to go back to assembler for something after coding in C for a couple of years. It was PAINFUL. It was SLOW. It felt so utterly MORONIC to even be writing an app entirely in assembly in that day and age of compilers that did a pretty damn good job without the slow, torturous pain of tracking registers, PC-relative addressing, stack pointers and all that junk.
Today was a mirror of that. The first thing going through my head is "Why the fuck should I be fighting over the proper syntax to write a fucking loop?" "Why should I have to remember all these damn Python footguns?" "Why should I be trying to remember if it's var x or <type> x or x: <type> or x := something or any of the crazy ways I've written it over the years depending on the language??"
My velocity was so slow it felt like I was walking in molasses. My thought flow was jagged and irregular as I fought for every line of code, trying to decompose the algorithm in my mind into primitive steps, just like it felt when I went from C to assembly that day. It just makes no sense to write code this way!
I probably won't get the job, but I also realized that I probably don't want a job that doesn't embrace AI assisted software development the way I do. I don't think I could handle working that slow again, even if the pay is great.
There really isn't. There may be more to shipping products than writing code, but in organisations of any size that's been specialized into different, other, roles for decades.
Just as we don't care too much about how AI does the little things, one has to make space for human engineers to be different from each other and from oneself. I felt I wasn't delivering much value by asking "did you use a list comprehension" or even the spotting of small mistakes. The value I needed to bring was a level up - whether the change hangs together logically with the rest of the codebase and whether the tests really test that and how will this fit the requirement or complicate the future.
As a non coding manager I could still program but I really didn't understand the technical problems my team was facing in the codebase until I got in there and learned it by doing work. It was very difficult to do this while doing the management side of things that eat up time - like hiring people or trying to extract the actual requirements from the wider business but in the end I was able to shelve some of that and get back to code which turned out to be essential.
When I understood the technical problems I could plan and make reasonable team lead type decisions. I could also give my management better information too which they obviously didn't like because it was about things like "that's logically nonsensical and therefore technically impossible."
For example, when designing GUI, you should have a clear split between logic and presentation. They should communicate via a queue, therefore, you can easily verify that the logic works as expected given the inputs. The UI layer is then free to do whatever it wants.
This is what I am doing with my text editor, I have:
1. a crate that have all the shared enum
2. a backend that drives the logic, LSP
3. various kinds of frontends, floem, iced, tui
Doing that as a human writer is extremely cumbersome but the amount of code does not really matter anymore.
None of this is new of course, but we know need to make things ergonomic for "humans" to write ala React. Instead, we are really just a somewhat knowledegeable PM that can drive a team of agents to work.
For example, right now, I am also working on an FPGA project. Do I know how this works? Somewhat. Do I know all the different type of RAMs, LUTs, special hardware, DSPs, routing mechanism, MUXs, TCL, bespoke Vivado tools?
No. I don't. And yet this thing parses UDP packets just fine.
Before claiming you had any skills in the first place ask llm to review your code.
Rapidly growing cve database proves most people wildly overestimate their competence.
So I don't think the title claim is correct.
There aren't much different things you can do to review codes.
If you are building a business or product you take the edge and get really good at that edge deeply, which MAY require knowing certain pieces under the hood and CAN also mean letting go of what no longer matters. If it starts feeling like nostalgia, an emotional feeling of loss, or a guilty pleasure you are looking for enjoyment and not value and it could cost you in the race.