Writing code used to be the hard part.
Now an agent writes it. Another agent reviews it. You get the pull request.
Code got cheap. Knowing if it works did not.
Here are seven ways this is rewriting the developer’s job. Some I welcome, some I don’t (number 6 especially). All of them are already here.
1. Line-by-line code review is dying
Engineers are skipping the code read during reviews. The focus is moving to architecture, design and structure. Many teams won’t admit it, and many engineers don’t like it.
The cause is volume. Agents write code faster than anyone can read it, so review became the bottleneck. A 2026 study of GitHub pull requests found that most PRs opened by AI agents get no review at all, and review activity on the rest is dominated by other agents.
Reading less is fine only if something stronger takes its place. When Bun was ported from Zig to Rust, the pull request added over a million lines. Nobody reads all of that line by line. What made it mergeable was a language-independent test suite with around a million assertions, reviewer agents whose only job was to find bugs, and fixing the process that generated the code instead of patching the output by hand. The engineer leading it still read a large part of the code side by side with the original.
The human sat outside the loop: watching it, reading samples and changing the process when the agents got something wrong.
That is where human review is going: the design, the constraints and the verification system. The risk is dropping the line-by-line read and replacing it with nothing. AI-written code looks polished, which makes its bugs harder to spot.
2. Clean code, indentation and other visual details matter less
Indentation, formatting and visual polish matter less now. The model reads the code, not us.
Those rules moved into a formatter, a linter and a file like AGENTS.md or CLAUDE.md. That file can describe structure too, but it is guidance, not a guarantee: Claude Code’s own docs call it context, not enforced configuration. What must always hold belongs in a check, like the linter or the tests.
Organization still matters to the agent, though. In a study with 660 Claude Code runs, cleaner code didn’t change whether tasks got done, but it cut tokens by 7 to 8.5% and file revisits by about a third.
3. Testing becomes more important every day
Each day, testing becomes more important to ensure functionality, quality, reliability and system stability.
With agents, the test suite is more than a safety net. It is the specification the agent works against, and the fastest way to find out whether code that looks right is right.
Two habits pay off quickly. Ask the agent to run the existing tests before it changes anything. And have it write the test first, then confirm the test fails before the implementation exists.
Two warnings as well. Weaker models in particular can write tests that pass by construction and prove nothing, so the tests need review too. And a green suite is a minimum, not a guarantee: the Bun port passed 100% of its tests and still introduced 19 known regressions (all fixed since), mostly from code that looks the same in both languages but behaves differently.
4. Some engineers have completely stopped writing code
Some engineers have completely stopped writing code. Typing it yourself is starting to look old-school.
This is no longer a fringe claim. Boris Cherny, who leads Claude Code at Anthropic, said in June that he had not written a line of code by hand in eight months.
But stopping typing is not the same as stopping engineering. Anthropic’s own research says developers use AI in about 60% of their work and report being able to fully delegate only 0 to 20% of their tasks. The rest still needs supervision, validation and judgment.
The work moved to planning, specifying, reviewing and verifying, and AI is taking on part of that as well. At Anthropic, according to Fortune, several Claude agents with different perspectives collaborate on code reviews. Some agents can also record the app running and attach the video to the pull request, so the reviewer sees the fix working instead of reading “tested locally”.
That makes checking cheaper, not optional. A video shows the path the agent chose to record, not the edge cases. Someone still has to know what the right result looks like, and without that knowledge you are just hoping the output is right.
5. Switching languages is becoming easy and common
Switching between languages is becoming easy and common. We are seeing systems being rapidly rebuilt in other languages for performance and quality.
The choice of language used to be close to permanent. A big rewrite could cost a team a year of work, so most projects avoided it.
Bun is the clearest example so far. About 535,000 lines of Zig were ported to Rust by one engineer directing agents, and the full test suite passed on all platforms 11 days after the start. The team reports a runtime that is 2 to 5% faster, with a binary about 20% smaller, and 128 bugs from the previous version fixed so far.
This is one benchmark the Bun team chose, but it shows the kind of bug the rewrite was meant to remove: in the Zig version, memory kept growing with every build.
It is not only infrastructure. Simon Willison wrote about a company that used agents to rewrite its iPhone and Android apps in React Native. Their reasoning: if it turns out to be the wrong call, they can port back.
It is not free either. The Bun port cost around $165,000 in tokens at API pricing, and it is the high end of what is possible today: Bun belongs to Anthropic and used a pre-release model for much of the work. A faithful port also carries the old design with it. About 4% of the new Rust code still sits inside unsafe blocks. And the port only worked because a large test suite already existed to check it against.
6. LinkedIn is flooded with posts written 100% by AI
LinkedIn is flooded with posts written 100% by AI. To me, the quality of the feed has dropped a lot, and a good part of what I scroll past reads like no person ever touched it. Of the seven items, this is the one I see as clearly negative.
There is at least one large measurement of the volume. Pangram, a company that sells AI detection, analyzed 1,002,627 posts that opted-in users of its Chrome extension saw in their feeds between late April and June 2026. Among posts over 250 words, it flagged 41% of the LinkedIn ones as fully AI-generated, the highest of the five platforms it covered.
These numbers deserve some care. People who install an AI detector are not a random sample of users, the company has an interest in the result, and “fully AI-generated” is a detector’s estimate, not a confirmed fact. The study also does not measure quality. That part is my opinion.
I have nothing against AI as a writing tool. Fixing grammar or tightening a draft is fine, especially when English is not your first language. What bothers me is a post with no real experience behind it, where nobody did the thinking. Generating text is cheap now, just like code. What you have lived and checked is what still sets a post apart.
7. Seniority is getting harder to read
Seniority can be confusing for an inexperienced leader. A senior developer with orchestration skills can build an MVP system in a few days, whereas a senior who hasn’t yet adapted to the new reality might have considerably lower productivity.
Experience alone does not guarantee the gain. In METR’s early-2025 trial, experienced open-source developers took 19% longer with AI tools, while believing they had been about 20% faster.
Output volume misleads too. In 2025 data from Faros AI, engineers with AI completed about twice as many code changes, yet company-level metrics stayed flat.
So don’t judge by the title or by the amount of code. Judge by what gets delivered and keeps working.
What ties it together
Producing code is no longer the expensive part. Knowing whether it is right still is. Review, tests, structure and judgment are where the job went.
Not all of it is good, but it is happening either way.
If this was useful, share it with another developer
