back
303 comments
Apparently it's not obvious to everyone, but if you can't write code, you can't review it. I do know people, and companies, that says: "So what, we ask Claude to write the code, Codex will then do the review". The thing that then strikes me as odd is that they still ask for the code in Python, Java, or some other high level language.... Why? Just ask Claude to dump out assembly, or a compiled binary, but no, they don't trust the LLM that much. They still want to be able to read the code. So they need developers that can read, debug and reason about the code, yet they don't want to give them the training that's required to do this?
They don't have Claude write assembly because there is no training corpus on people making CRUD apps in assembly.

I'm as hateful of LLMs hollowing out the job market as the next guy, but the reality is the frontier LLMs are really good at writing anything that's been done and documented on the Internet a million times and unfortunately most of what software devs have been doing the last couple decades is shitting out cookie cutter CRUD apps.

I have my doubts about whether the state of the industry is going to advance as long as we're having LLMs do all the creation, but that's another diatribe.

> Apparently it's not obvious to everyone, but if you can't write code, you can't review it.

There's more to it than that: writing is thinking. If you stop writing code, you aren't thinking anymore.

Many argue that they're now thinking at a higher level (maybe they weren't before?), but, guess what, that high-level design can be done better by the LLM than by you anyway. It's only temporary.

I’m finding it all boils down to cognitive differences.

Some people find code easier to read than the English description. It’s more precise and many experienced devs can scan it and know what’s happening

Many other people can’t read code. Or they find English easier to read than code.

Thats not a knock on anyone. Maybe the latter will rule the world because the former focuses too much on irrelevant details. Or maybe me there are just different types of problems that need differing levels of attention to detail.

Pretty sure Casey Muratori and Demetri Spanos cover why in one of their videos online.

Less about “trusting” the llm and more about how complex it is to work with binaries due to machine code being different per machine and hard to interpret the context of the code as well as offsets.

In that sense because high level languages come with the ability to add context to what code does. It’s like the understanding a human has when given decompiled C code ghidra gives you vs C source code a developer wrote.

Also the compiler helps the llm write “compiled / working code”, if it just spat out machine code it most likely not even run at all.

But yea generally if you can’t write code at all, reviewing it is even harder.

First of all, obviously there's more training data on high level languages than assembly / compiled binaries. Secondly, Python, Java or even C is portable to another device. You know, one of the main points of high level languages: that you don't have to rewrite your app from scratch each time you want to change the machine it runs on.

Thirdly, compilers also do type checking and other static analysis and dynamic checks (array length etc). So it's not only got more guardrails against "mistakes" by the LLM, but it's also most likely "easier" for the LLM to "reason" about (in the sense that LLMs can reason).

There's no intrinsic value to having humans read the code, so as soon as LLMs are good enough to work on their own, companies will no longer need to keep developers who can read code as a backup solution.

I have a few personal projects, i let codex do all the code - i do the thinking and testing.

One time, something didn't work as expected - its the first time it happened with this project. I read through the section of code and it was perfectly readable and well-written.

Turned out a plugin wasn't effecting the audio, so i just got it to pad some blank audio onto the beginning before processing it, then remove it at the end of the process. That fixed the issue, there was nothing wrong with the code but my ability to think laterally is what made it work.

We're getting to the stage where you can just ask them to write code and they will do what you want, and it writes good code. Its up to you to test everything beyond the internal tests it writes.

> Just ask Claude to dump out assembly, or a compiled binary, but no, they don't trust the LLM that much

No, people do advocate for this. It may simply not be as portable however as something that is high level able to be compiled to assembly for many machines.

> Apparently it's not obvious to everyone, but if you can't write code, you can't review it.

Why review it at all? The trend is to vibe code everything with agent harnesses and tokenmaxxxing.

No defense for not writing or reading code if want to call yourself a software engineer or programmer.

However I do think there is reason to use Java or Python (as much as I loathe both) they have GC, and it'd be a lot easier for AI to fuck up memory safety in something like assembly or C.

“Do you know what the industry term for a project specification that is comprehensive and precise enough to generate a program?

Code. It’s called code.”

- CommitStrip (https://www.reddit.com/r/ProgrammerHumor/comments/1p70bk8/sp...)

I think if you’re doing it right, the core of your code should be the simplest expression of the underlying business logic. Of course there’s always going to be supporting layers, and maybe those don’t need to be reviewed. But if you haven’t read the code, there’s an extent to which you don’t know the business logic.

"It’s about attention and understanding. To keep my attention, I must go beyond ‘read code’ like a passive observer of agents from afar. To really connect with the architecture of the system, it helps to truly experience the code"

I guess the funny answer that is behind this sentence is: You have to train your own mental model. We always argue about code in a very abstract and logical manner. But when coding the subconsciousness makes most of the decision ("this just feels right"). But for this to work you have to train it. And this does only work in a very limited way with code reviews or reading documentation. It requires repetition and deep focus.

When there is an issue in production with this mental model you will be able to point to the cause of an error message instantly. With generated code you'll search for a long time with your slow, conscious part of the brain.

For LLMs to be really helpful, they have to take over complete maintenance of the code. So you can treat them like an external library: Just assume it works. Otherwise this will always be problematic.

The relevant question is who is going to pay you to write code manually. It's something that's increasingly hard to justify. The answer is of course that people are not paying for code to be written or generated but for some problem to be solved. Whoever does that with the least amount of drama and cost gets the business. And using AI tools just allows for compressing the timelines a bit in a way that is hard to ignore.

Most code out there isn't all that great. I've been in this industry since the nineties. There are a lot of not so great software engineers doing mediocre work. People are romanticizing how great and magnificent their code is (or used to be). The reality of manually crafted code is of course a lot less flattering. Many code bases become hard to maintain over time and are riddled with bugs. And it's not like sloppy code is a new thing. Poorly executed software projects have been very common for a long time. That's not going to go away.

I need to write code because otherwise LLMs will write too much code, it’s only when you fully understand the problem you can generalise it enough to not end up with 10k lines and 5 abstraction layers for “hello world”. LLMs are token predictors, so all solutions are you tokens, the more problems to solve == the more tokens (code) to output.
> For example, have you ever seen an agent follow the boy scout rule? Where they leave code better than they found it? And would you WANT them to try to do this?

Yes, it's in the rules; run profiles, check code coverage, do a critical review, post the report and follow up tasks. 90% of people I've worked with did not follow these boy scout rules nearly as well as today's frontier LLMs.

Is the author implying this is bad?

> If we’re building a software factory, details matter. The details that establish architectural patterns. Down to algorithms and performance. Agents push us to evaluate, measure, and guard. They’ve made it cool to add CI into side projects early, not as an afterthought. That’s massive improvement to the state of software.

Why are you building a software factory though, and why weren't you immediately adding CI to every project?

> It’s our job to build the software factory - not just the software. Software engineers maintain the assembly line allowing anyone to prompt for a change and ship immediately.

Again, why? Where are you working where this is considered a good idea? This would mean that the software engineers are not just being completely kicked out of all business decisions, but asked to build a moat that ensures they stay on the other side of it.

Any business that intentionally devalues the insights gained through implementation will eventually starve itself to death by making too many passive thoughtless moves. No insight will ever be gained just spot checking AI. Is their intention really just to make tiny amounts of profit while riding the thing into the ground? Crabs in a bucket, man.

If we look at the progress made from ChatGPT 3.5 (Nov 2022) and up to today...shoot, I'm really starting to wonder if we'll even be reviewing code in 4 years.

And I'm not saying this as some sort of AI maximalist. If progress keeps up, I seriously doubt software engineering and development will, as we know it today, will be a thing in the next 5-10 years. Maybe humans will be left with designing the UI, but everything else will be abstracted away and AI will be doing all the actual work behind the scenes.

I always hated writing code but loved debugging. LLM super charges systems thinkers & auditors, it’s just a different process and no different than copy and paste from stack overflow. It all comes down to the architecture design and LLM just exposes how bad people are at designing dynamic architectures.
"Instead, we’re switching to this wrong-headed mindset that coding agents are like compilers. That mindset gives us permission to ship terribly written code. Agents aren’t compilers - they’re more like freshly onboarded interns."

I feel this statement these days during code reviews. I know some amazing engineers whose output lately just isn't the same.

i write code because i love it. it's something that makes me genuinely happy, so why would i give that up?
I write code all the time I can, outside the KPI metrics that everyone is being pushed to, I only care about AI for smarter code completion.
>It’s our job to build the software factory - not just the software. Software engineers maintain the assembly line allowing anyone to prompt for a change and ship immediately.

The job of the software engineer increasingly becomes to make himself unnecessary: to empower the nontechnical business users to do as much as reasonably possible, without his/her intervention.

This has, of course, been the dream of computing, since its inception! And the true aim of every "high level" or "beginner friendly" (looking at you javascript!) language.

But finally, now that the computer actually speaks English (and is beginning to stop making completely insane errors), it gradually becomes feasible.

Freeing the masses from the tyranny of the nerds!

"Why write code in 2026"..

Because AI generated code is STILL complete ass. Even Fable, even whatever custom Pi/opencode leet code harness you have, the output is awful, and, if you cannot distinguish the quality of your code vs the AI's, I've got some bad news for you.

At this point I haven't looked at code for many months. Before that, I spent 4 years hand coding a Google Docs competitor in JS without any libraries.

My brain feels equally as exercised (in fact more so as I am not as good at agentic coding as I was at real coding)

But now I'm making highly polished Mac OS apps and I really like that move from JS.

I feel... conflicted.

If you’re not writing code it won’t be long until you get to a point where your agent won’t be able to dig you out of whatever hole you’ve dug for yourself and then you are fubar because you’ve just completely forgotten how.
Seems like there’s broadly two ways to use LLMs for coding - either as a way to generate the same code you would have written but faster, or as an opaque program-generator where you have no idea what the code is doing. One of these methods results in roughly the same amount of understanding and the other one radically less.
Note as some may be confused by the "1 hour ago" with comments older than that: this submission was rescued by dang when a previous discussion existed: https://news.ycombinator.com/item?id=48883341

fwiw I think the rationale behind it is counterproductive because the only difference between a OP submitting their article link and someone else submitting their article link is internet points.

Unless you want some unmaintainable shitty sloppy app.
I write organic code in 2026 because I do not have a choice. Which, honestly, I am thankful for most of the time. My employer has no LLM mandates nor do they supply us an LLMs to use.

In my personal life, I cannot justify more than a $20 sub per month. I only use the Web Chat anyway. Shelling out $100-$200 a month for a sub in which I would get little to no ROI is a poor choice. Besides, I've never hit the limit on my $20 a month plan either.

The day I am forced to prompt LLMs all day, every day is the day I am cashing out of programming as a career. Though to be clear, I have no opposition towards anyone that uses LLMs, and think they are fantastic tools when used appropriately. (I love them as a StackOverflow replacement, and have learned a lot from going back and forth with LLMs).

    Writing code helps me think.
Every time I read some take about keeping up one's skills when using agents people get so tantalisingly close to the obvious answer, and then fall short.

If the tools are making you worse, don't use the tools.

Do ppl think that programmers just write code from sratch each time..?!

Even without AI I barely write code. 95% of time are spend setting up integrations, configs, copying & adjusting code from previous projects.

I was thinking about an experience I had recently, and how it relates to my feelings about AI... And it bummed me out a lot.

So I took over an open source project called Omnivore. It's a reading app in the vein of Pocket. The hosted version used pdf-lib to inject some functionality into the pdf viewer. Namely, highlighting, note taking, and storing location. pdf-lib is a licensed application, so when taking it to fully self-hosted this needed to change.

I migrated it over to pdf.js. And I went through the entire process. I added all the functionality bit by bit. It didn't take exceptionally long, maybe 1-3 days. But that process was really satisfying. I found a bug, fixed it, and then found a stackoverflow issue where someone was also experiencing the same issue and suggested the fix. https://stackoverflow.com/questions/59151218/pdfjs-error-on-...

I'm pretty sure an ai could have done all of this. And therein lies my fear and my upset with AI. Not only would it have robbed me of that experience, but it shows that I have in a way been devalued. Because I do think that took a level of skill. And now that's gone...

I’d like to recommend people to read the “Programming as a theory building” article and why the code itself isn’t enough to understand the whole context of a complex project.

Every time you work in a complex software project, you have all the context in your head about what you must take into consideration. LLMs don’t, you have to explain every little detail to them, but there’s no telling where it stops: do you have to explain X to it or is it in the training already?

When you try to shape how a LLM should behave and what it should know, you end up writing a Bible of relevant context that’s increasingly difficult to maintain as well, often with outdated or contradictory information, and it is still free to ignore things you have written and proceed however it wants.

That’s why so many people only feel comfortable giving the LLM some limited task to do, because you can judge if that specific task needs just enough context that it can handle by itself.

This is too generic. There's some code I need to write like core abstractions that are going to set the pace for everything. Or tricky steps that can look good without actually working well.

Then there's the mass. I don't need that anymore. The mountains of boilerplate, etc.

I write little islands which need high judgement that are then connected by the obvious goo.

This resonate with me a lot

Recently I am seriously thinking the time when agent do the work and I was waiting for it's output, I got a bit lost given it really can do a lot but it make me feel some crisis as a human, even it still can provide me a sort of Joy because some task I long want to do but no time to start can be finally take shape, but the Joy is actually not comparable with the Joy when I read the code and hack with it

Concretely, I am letting agent to write some serious part of code to rust and I will consider only let Agent to handle the UI and integration stuffs, and I will take the rust part and rust is a language that I want to learn and be professional given I was do lots of C coding

I enjoy writing and read code as well, but AI race force me to skip that part to be able to ship faster.

I spend time building AI Agentic guides and skills, then review the code myself. I really miss the old days when you put your headphones on and focus for 3-4 hours

I feel like this question doesn’t need a blog post to answer.

Why write code in 2026? Because it’s fun.

This does not seem obvious to AI-developers, you cannot fix what you do not understand.

Also, if you use AI to write your code, you are not a developer either.

Let's say AI completely disappears right now, many of the so called "developers" are unable to write code, are unable to fix code, they cannot code.

There are two kind of developers:

1. Non-developers: Use AI for everything, to write code, to test the code, you name it.

2. Real developers: Search engines are broken right now, they use AI as a tool, as replacement for Google to ASSIST you, not to do the task for you.

As AI is falling apart and companies are hiring people back, these non-developers will find themselves out of work.

I think fragility is the key reason i intervene in llm code too. Good article.
The most interesting and creative projects I have worked on required little code, but novel combinations of ideas.
Why is this even a legit question? I need to keep writing code to stay relevant, not to forget my craft, be able to review code... So many reasons. AI doesn't change a thing.
I discovered Doctorow's "Reverse centaurs are the answer to the AI paradox" via a link in this article.

It was a great read.

Recent HN Discussion: https://news.ycombinator.com/item?id=48873855

Prediction: in 2027 a coding agent will read this as inspiration for why it should code.
I still exclusively write my code. The quality is higher. I know exactly how it works. It’s more extensible. You don’t have to generate it.
To build software that you understand yourself. Next question.
I found myself working mostly at the requirements and architecture level, but do not give up proper code-review, creating skills along the way that maintain conventions.
The OpenGraph preview image for this article is a total ragebait
All this debate around use LLM or not is tiring and just black and white thinking.

Can I use agents to code a SWE project? yes, with nuances.

Can I write code for a SWE project? yes, with nuances.

Its more options now, I'll write code about projects I deeply care and will use llm at work where its shared slop and forced usage.

Arrogance, vanity, ignorance... etc.