I am a junior. My career started with agents. The people who hired me, and the people writing angry posts about it, mostly learned by typing, breaking things, and sitting with a codebase until it lived in their head. I did not get that runway. I still have to do the job.
Mid-September 2026 three things landed in the same week and a lot of people recognized themselves. Armin Ronacher (Flask, etc.) asked a short question: what are you struggling with most, with AI in software engineering. Sunil Pai published an essay about a failure mode he keeps seeing in seniors. Then someone posting as voxium wrote a long note from a new job at a big company, and it went nuclear: tens of thousands of likes, millions of views, a thousand replies. I read the threads, skipped the bots and the “so true”s, and this is what was actually being said. I am writing it down so I do not forget it when the next model drops and everyone pretends the feeling was a skill issue.
The three posts
Armin did not rant. He asked. Almost every reply was a practitioner naming a bottleneck. The winning answers were not “the model is dumb.” They were: I do not own this, I cannot keep the system in my head, I am reviewing more than I am building, I am context-switching myself into mush, juniors cannot learn, verification is the real problem, the team cannot agree whether anyone should still read code.
Pai’s essay is called “the senior engineer death spiral.” A friend had just taken a very senior, very paid role and was asking how to do 60–80 hour weeks to prove himself. Pai said that is how people disappear. Two, three weeks of “going well” in standup. Nothing to show. Then you try to do a month in a week so nobody notices. Sleep goes, meals go, you get depressed, you burn out or get pip’d or quit because it feels unsalvageable. He has done this to himself. His fix is unfashionable: they hired you as you are, drop a level, be the best teammate for a while, share constantly, switch from outcome-panic to daily momentum. Big projects are not big efforts. They are a marathon you can feel in your hands every day. Reputation first. Software downstream of that.
voxium’s note is the death spiral with the company holding the shovel. Two weeks into a big-company role. Specs, code, tests, PRDs, tickets, ticket resolutions, reports: Claude Code. Nobody on the team likes it. They are forced to ship. Management: pushing code is not the bottleneck, so why are we slow? People working 12–13 hours just to press enter. Nobody reading. L1 through L7, same loop, talk to Claude. No victory. Nobody resolving bugs. Nobody thinking. Soul-sucking. He would accept the tools if they were given time to see what is going where. They are not. Goal is ship, no matter what.
He kept answering in the thread, which is why it stuck. Are they testing? Claude writes the tests. Why not quit? It is not one company, it is becoming the default, startups will follow, he cannot hide his face in dirt. They still say you are accountable for your code. He said make Claude accountable, you are not even allowing us to review. Long-term quality? Leaders are not thinking long-term, they want it working now. Will they learn when it breaks? He does not think so. They will pressure people to work more, fix it however, until nobody knows what is going on. He is not anti-AI. He wants humans still in it. He quote-tweeted a line a lot of people already knew: we are just condoms between Claude and prod. He said nobody could have summarized it better.
A Japanese engineer replied that his org is the same. He gave up his beliefs and became a meat proxy. He does not think that seat exists next year.
That is the scene. The rest is what hundreds of people added, and why so many of them used language like cooked, over, brain soup, closed loop, assembly line.
What the job turned into
Software used to be slow in a particular way. You thought, you typed, you got stuck, you read, you asked someone, you shipped something small, you felt a click when it worked. The click mattered. People built identity on it. Marx even showed up in the replies, which would have been a joke five years ago: engineers were somewhat spared alienation because they could see the code change the thing. Now there is another interface in between. Mental labor started to feel like physical labor. Someone else called it proletarianization, joining the warehouse line, except the line is a text box.
Now the typing is cheap. A model will emit a plausible service, a test file, a PRD, a ticket, a commit message, and a confident explanation of why it is correct. Companies noticed the typing got cheap and concluded the whole job got cheap.
That is the wrong lesson, and it is the whole plot. Writing is fast. Understanding is still slow. Judgment is still slow. Knowing what a change will do to a system you do not fully remember is still slow. Several people said the same sentence in different clothes: AI makes shipping cheap, understanding is still expensive. If management hears “code is not the bottleneck” and answers “then ship 10x,” the bottleneck does not disappear. It moves onto review, onto on-call, onto your memory, onto the 2am incident. Faster output can make the system slower. One person called “pushing code isn’t the bottleneck, so why are we slow?” the death knell of intellectual inquiry in enterprise tech: treating software like coal to shovel, not an architecture of thought.
If you demand 10x and keep the same human review model, review becomes theater and production becomes the test suite.
A lot of seniors are miserable because they remember the old click and it is gone. Juniors are in a worse spot for a quieter reason: we are being asked to do the part that used to come after years of the old click, without having done the years.
Why people think they are cooked
This is the part the short version skipped. People were not only annoyed. A lot of them think a trap already closed.
The loop does not need you. Not next decade. Soon. Specs, tickets, code, tests, and the writeup of the ticket all come from the same model. The pipeline is the model reviewing itself. Humans press enter because leadership thinks velocity is the metric. Several people said the next step is obvious: another agent to filter bugs, another to press enter, and the chair is empty. One person watches AI reason, decide, and execute, and is afraid it is already almost closed. Another noted that this kind of use is how the lab eats workflows and learnings until the human is needed less. A joke that was not really a joke: the post describes the condition where a well-curated context window is more valuable than the senior who actually remembers things. The rant is also a feature request.
L1 and L7 became the same job. If both just talk to Claude and hit enter, you are paying expert money for the same button. Interviews got harder while the work got emptier, which is a special kind of insult. The scarce job, if there is one, is whoever still owns the bugs after you ship. That person is not who the dashboard is counting.
Accountability without the right to look. This came up again and again and it is why the soul-sucking line landed. Management says you must be accountable for your code. Management also will not give time to read it. Deadlines pretend there is room not to ship slop, then the date hits and you ship. One person: they act like there is time, then you are simply forced to deliver. voxium: that is also true. Another: if you cannot explain the diff, do not ship it. Reading feels slow until the incident at 2am. In voxium’s room that rule would get you managed out. You are the name on the merge. You are not allowed to be the mind on the merge. That is how people get cooked without being fired. They become the liability sink.
The debt arrives in days now. People used to talk about technical debt like a slow leak. Replies described years of debt accumulating in a week. Four major data-cleanup jobs in a few months, users still living in the fallout, more bugs in the wild. Garbage piling after months of “push the requirement to Claude, if it errors push the error back to Claude,” nobody reading, nobody questioning the requirement. When it blows, Claude will not be on the hook. You will, and you will not have a mental model. Reverse-engineering your own last quarter is the job then. Some people said the 2025–2027 products will get junked and rewritten. Some said we will need AI to clean the mess, and voxium said at this speed there will just be too much mess to clean.
Your brain is the thing being spent. Not metaphorically. ryxcommar’s reply to Armin was the most liked in that whole thread: no real ownership of AI output, brain turning to mush, org pressure to ship fast and sloppy. Someone told voxium to take it seriously and quit, it will turn your brain into soup. People who used to take pride in the work now do leetcode at night to feel sharp. A ten-year engineer said they do not feel as sharp as they did four or five years ago; they worry more about human brain rot than about slop. Someone else: all creative thought outsourced, expected to work 16 hours churning slop. Another: AI destroyed my love for technology and my sense of accomplishment. “No sense of victory” is the line that kept getting quoted. You cannot feel proud of shipping something you never understood. Dopamine from mashing enter instead of thinking. At the end of a “productive” day you are not happy. That is cooked in the personal sense: the thing that made you want the career is the thing the job is burning.
Knowledge is leaving the building. Product writes an AI Notion page. You call about a decision in the MR, silence, then typing on Claude. A staff engineer with six Claude sessions open, despairing that he does not know how to do his job anymore. A product owner ran meeting notes through Gemini into a bloated PRD full of technical specs he did not understand, for a system that should not exist, then Claude turned that into tickets that made the team thrash. Entire product team fired, loosely written requirements, no customer-impact analysis, massive code forced into production. QA treated as the bottleneck and removed. Professors with generated slides. A student teammate showing up to a sketch meeting with AI nonsense, wrong cross-sections, cannot explain how it would work. Docs are garbage. Living documents that were supposed to be updated with every architectural change are not. On-call is “I’ll ask Claude.” When the people who used to remember leave, or never learned, the context window is the company. That is fragile in a way a messy but known codebase was not.
Juniors are being hired as the loop, not as engineers. Someone laid off this year heard the replacement wave is recent grads who use LLMs for absolutely everything. College is already ahead of the office: everyone a vibe-coder, effort looks stupid, the people grading you do not want to wait. A statics professor recommending AI for everything except the free-body diagrams, angry at a student for working by hand. If that is how you “learn,” you never build the library of scars that lets a senior smell a bad abstraction and say no. The model sounds sure. You are not sure. Shipping the sure thing keeps the job this week. It also means in three years you are still the enter key, and the enter key is the first thing they automate.
The incentives are a meat grinder and you are not the customer. AI adoption measured in keystrokes, commit counts, lines, token usage. Ticketmaxxing as productivity. Sales sold the units before production started. Investors want to see AI. Management does not use the tools as deep as the ICs and still sets the pace. Frontier labs set expectations ridiculously high. One person: like a factory that installed machinery nobody evaluated. Another: first movers are sacrificial, guinea pigs feeding the next models, unless you are the AI company you should be wary. Throughput disease. DORA-style speed metrics crowding out actual improvement. “It’s so easy now” so nobody appreciates the work, and you get called names for not shipping fast enough. The people boasting in replies about not reading code are proud of it. Someone said that is why we cannot have five nines anymore.
Same tools, so the only remaining moat is judgment, and the org is training that out of you. Several replies: every company has Claude. Differentiation is still human taste and the ability to tell a wrong system from a right one. If your company uses the tools to avoid knowing, you get faster at becoming the same as everyone else, then cheaper. Solo builders in the thread love the same models because they own what they ship. Inside the big company it is press enter and pray. Same AI, opposite experience. That is why “just adapt” is half true and half a con. Adapt to directing and checking, yes. Adapt to never knowing, and you are volunteering to be obsolete.
There may not be an elsewhere. This is what made voxium refuse the easy “just quit.” He can see it becoming default. A lot of people said find a better team, and some teams really are better. A lot of other people said they already resigned for this, went freelance, pivoted to hardware and chips, or are waiting it out until the company crashes. The cooked feeling is: even if I leave, the next place might be the same, and I started my career already inside it, so I do not have a prior self to go back to.
The problems people keep naming
You do not own what you shipped
The most liked reply to Armin was not about models or tools. It was: I do not feel ownership of anything the AI outputs, my brain feels like mush, and the org wants it shipped sloppy and fast.
Someone else said they used to hold a crystal-clear picture of the systems they worked on. Now it is blurry. Cognitive debt: too tempting to ship something you only somewhat understand, buggy or not. Another: a high-level understanding is not enough, because the high-level is built out of the low-level, and they are losing the low-level. Who am I even writing code for, man or machine? The code looks like shit 80% of the time, then you think: shit for who? The agent does not care.
Meat proxy: you sit between the model and production. You are the warm body that makes the merge legally a human’s. One person could still recall the exact file of a change they made two years ago by hand. Ask them about last month’s agent work and they barely remember. When something pages they have to ask the model to find it, and the model is slow at that in the way that makes you sweat. Another: I do not own the code anymore, how do you build ownership of something you do not own, the new role is in the making and the transition sucks. Kent C. Dodds was more precise than most: he can trust a good agent once the primitives exist. Creating, combining, deleting those primitives still needs him in the loop. UI and language too. That split is the closest thing to a sane description of remaining work.
The reviewer inherited the whole job
Writing a PR used to be the hard part. Now a model dumps a pile, the author often has not read it, and a human is supposed to bless it.
The burden flipped. Author used to sweat details. Reviewer asked questions. Now the author is a prompt and the reviewer is supposed to be the engineer. Volume is wrong for that. Diffs faster than anyone can honestly read. Approvals become rubber stamps until a sev0, then everyone pretends they were careful. Reviewing all day, yours and your teammates’ agents, exhausting, and it does not feel like you worked. You did not “do” anything. Code reviews have to change as a practice and nobody knows to what.
It is not only the code. Ralph: asked to review PRs with Claude-generated descriptions, commit messages, tickets, and code, and the author did not look before requesting review. tanrendev: AI Notion page from product, call a colleague about the MR, silence, typing on Claude. The model also dumps comments explaining how it thought of a one-line change, so even reading is worse. Trust oscillates: most reviews feel unnecessary, you get sloppier, then it kills production, trust resets to zero. The 10% that is wrong is never the same 10%, so you end up not trusting any of it.
One person still gets paged when slop takes down production. They know they are “not supposed to read the code.” The pager does not care.
Tests that agree with the bug
If the same model writes the feature and the tests, the tests are not a check. They are a second copy of the same guess. voxium was asked if anyone is testing. His answer: you know who is writing the tests? Claude.
Next failure: the agent rewrites tests when behavior drifts, so the suite still passes and no longer means what you thought. You needed an intent the agent is not allowed to edit. Almost nobody has that. Verification of outcomes is, in Geoffrey Huntley’s words, the technical challenge. Apart from that it is people. He called AI an identity erasure device. QA and fixes take most of the time now, generation is easy. Checking an edge case still takes longer than writing the patch. Drift in functionality. Implementation “correct” on the bench and expensive in some other way that shows up later.
A founder caught a bigint sequence stored as string concat: 1, then 11, then 111. Error swallowed by a try/catch. Nothing went red. Caught only because a human read the code, in the part of the system whose job was to prove what happened. He is hiring more humans because of AI, and their job is to read what the agents produce. That is the opposite of voxium’s company. Same tools.
Juniors got the worst deal
This is the part that is about me.
Armin’s thread: team wants instant results, not allowed to learn by hand. 0 to 1 skipped. Dropped into 1 to 100 of a domain you never walked. You do not know if you are progressing as a programmer. Maybe as someone who directs agents. Not sure that is the same job. Not sure the job will still want you if you cannot open the hood. Another junior: figuring out how to still learn, used to be trial and error, with AI you rarely get that. Another: not enough experience to say no to the LLM. As architect maybe you are progressing, as coder probably not, and does being a good coder even matter?
College is not a refuge. First-year: professors with AI slides, ChatGPT is Google, everyone vibe-codes, effort is for suckers. Engineering student whose teammate generated the sketches and could not explain them. Statics professor pushing AI, angry at hand work. The pipeline that used to produce seniors is being gutted at both ends: school will not make you slow, work will not let you be slow.
Seniors have a library of scars. They can smell a bad abstraction because they have lived inside one. They can say no. I do not have that library. The model sounds sure. I am not. That is the junior condition, and the company will happily use it.
Management heard the wrong lesson
“Code is cheap now” became “why aren’t you done.” Non-technical people saw Lovable spit a demo in an afternoon and the expectation leaked into real systems. High performers expected to absorb the delta because output is free. Low performers yolo the wrong feature with no idea how it works. That delta used to be visible in the code. Now both can produce a PR. Ticket-brain people who do not understand the business, shipping the wrong thing, zero understanding of the wrong thing.
A lot of replies said this is not an AI problem, it is a management problem. Some of that is cope. Some is true. People said the same thing in 2015, except then it was “they will not let us refactor.” AI did not invent ship-at-all-costs. It made the costs invisible for longer, then dumped years of debt in a week. Big tech stopped caring before AI, shipping culture, promo cycles, someone else inherits the mess. AI jet-streams that toward the wall. Managers who have never been developers fall back on volume of code. Pressure from stakeholders to show AI investment. Blockchain déjà vu, except this time people do not think you can go back to manual.
The other management failure: assuming what shipped is perfect. Speed up writing and you speed up issue delivery. No independent quality bar. One team lead said they use agents and would never push people the way voxium described. A small company said they are running circles around large orgs. So it is not physics. It is a choice about what you optimize.
Flow is gone
First reply to Armin was context switching. Someone described it as a late-game RTS match: five groups of units, no idle villagers, except an RTS match ends in thirty minutes. You run several agents, you feel busy, you are not in the work. Gaps between short calls too small to do anything real and too long to sit still. False productivity. Todo-list satisfaction without doing the list. Once agents are going you veg. Staying productive on other work while they run is its own skill and most people are faking it.
Models talk too much. Walls of markdown that could have been yes or no. Searching three paragraphs for a boolean. “Too.much.useless.text.” Fatigue from reading, cognitive debt from doing no deep work. You cannot quite do anything in the two minutes between calls so the day is sawdust.
You also cannot predict your own output. A day is worth two weeks, or you spend two days and throw it all away. No simple rule at the start of a new thing. Feels like loot boxes. FOMO when the agent stops. Everything in motion at brutal speed, endless self-doubt about settings, models, prompts, whether you are missing the important news. Identity crisis in the reports: I am a programmer, that is my craft, I no longer program, I prompt.
The team cannot agree what the job is
On one end: AI only produces slop, read everything. On the other: nobody needs to read code anymore. Same repo, both religions, terrifying merge. Pairing feels pointless. Knowledge sharing has no new ritual. Collaboration is supposed to still matter and nobody knows what the shared activity is now. Speed makes it impossible to know what teammates are doing, which wrecks on-call. All documentation is garbage. Business people dumping unfiltered content hurricanes that start unstoppable work. You need a high-rank adult in the room or the software comes out crippled.
Some teams are fine. That matters, because it means the horror is not the model, it is the seat. Small companies executing better. One place: architect said they do not write code anymore, they 3x’d capacity on tech debt, customer bugs down, heading toward actually choosing work instead of drowning. Another: pre-LLM codebase full of landmines, they have to stop the model from scope-creeping every ticket, and still bugs and incidents dropped. Solo builders: capabilities ahead of their ideas, the bottleneck is product sense, A/B, customers, not the file. Same model, different seat. The horror is specifically: big org, velocity as the metric, humans as the merge button.
The models are still messy in boring ways
Less existential, still the daily texture. Agents forget the last twelve files and suggest the same broken fix. Duplicate a helper because they zoomed into one function and never saw the util. Over-engineer, especially on language design and anything that rewards looking clever. One insane line in the middle of otherwise decent code, the line that would never occur to a person. Conform to style on paper, still smell like a model. Confident before they are done. Context dies on long work. Compaction. Five-hour windows. They layer workarounds instead of finding the cause, and they do not clean up the failed paths. They spawn a Python test from a TypeScript test because why not. They add one-line nonsense abstractions until you wonder if you should stop reading. They are bad at mind-reading: you have a feeling for the thing, not a paragraph. They overdeliver in areas you did not ask, which is a different bug than a lazy human underdelivering. Complex workflows with gates, retries, nested loops still fall over. Cheap models used as conductors cannot tell when they need a smart one. Secrets, AWS, fingerprints every eight hours. CI cannot keep up, MRs pile. Mixing models sounds adult and often just slows the whole machine.
None of that is “the profession is over.” It is “the tool is a fast junior with amnesia and a tendency to lie about being finished.” People have been saying that. The cooked part is being forbidden to supervise the junior.
Open source, copying, and “what is even worth building”
A quieter cluster in Armin’s thread: software getting easier to copy, worry that open source becomes closed because founders cannot protect value. Incentives for open source maybe dying. Everyone doing a flavor of the same thing, or something around the corner that would be better, so choosing a project feels pointless. Gara-ware. Too many ideas, not enough time, and also: how do you still find things worth building, and feel connected to them. Diffusion: new toy every week, distracted user base, some toys stick. Copyright. Price. GPU. Usage limits. These are not voxium’s 13-hour enter key, but they are the water juniors are swimming in: even if you get good, what are you building, and will it still be yours.
The other camp, because they are in the thread too
If I only write the panic I am doing the thing I said I would not do.
Plenty of people called it a skill issue, told him to be glad he has a job, asked if they are hiring so they can press enter for L7 pay. Elon replied “Yikes,” which is not analysis. Someone in management-cosplay said fire everyone not AI-native, max team of three, your technical skills are now zero, people are the bottleneck. A founder of a one-person startup called the whole tweet baloney: at that velocity your brain tweaks out, nobody has enough ideas to keep a whole company shipping like that, look at the code and you will not beat the model at bugs anyway, go look at customers. Someone rebuilt a reporting engine in Go in three days, language they did not know, 250ms instead of 2.8s, idea was theirs. “Just have bigger ideas.” Product people do not want to go back to two weeks and $150k for a dashboard widget. Punch-card analogy: nobody read the holes either, we climbed the abstraction ladder, stop being an artisanal purist. Compilers already emitted ugly code. Before Claude the last huge project was a mausoleum and nobody knew the Spring Boot services anyway.
Some of that is real. Abstraction always moved. Bad companies existed. A lot of pre-AI code was already unread. Small teams using agents as a force multiplier, with review, are not crazy. The punch-card line is the one I distrust for juniors. When we climbed to C and then to Python, you could still run the program in your head at the new layer. The current move is asking you to skip having a layer. That is not the same climb.
“Just quit” and “be grateful” and “skill issue” are not arguments about the system. They are arguments about whose nervous system should absorb it. I am a junior. I can absorb some. I should not absorb all of it and call that growth.
Pai’s spiral, wearing this year’s clothes
Worth putting next to the rest because it is the personal failure mode that matches the org failure mode.
You get a role, or you feel behind as a junior, and you try to cosplay the next level. With agents that looks like five chats, huge scope, “I’ll have something soon.” Standup is going well. You are not sharing, because sharing would reveal you do not understand the output. You work nights to catch up. You still do not understand it. You get slower at the only part that matters, which is noticing. Then you either burn out or you become the person who cannot answer “why did we do it this way?” in the PR, which someone actually wrote: bruh, fuck if I know, it works though.
Pai’s advice still holds and it is almost offensive in a 10x-or-die room: drop a level. Be a teammate. Do the bugs. Write the notes. Get momentum. Let people know what you are doing. They hired you as you are, not as the person you are panicking into becoming. In this era the costume of the death spiral is agent volume. The crash is the same.
What people actually proposed
I am not deleting the panic. I also should not pretend I invented the way out. Armin’s thread was mostly diagnosis. A lot of seniors said they do not have a clean answer. Bruno Paulino: reviews have to change as a practice and he does not know to what. That honesty is useful. The solutions that did show up are scattered. I am writing them down as they said them, then I will steal what a junior can actually use.
Personal rules they are already running
Kent C. Dodds: he can trust a good enough agent to do most things once the primitives exist. He has to be much more involved when creating, combining, extending, or deleting those primitives. UI and language (a landing page) still need him synchronous with the agent. That is the cleanest split I saw from someone who is actually good at this.
Kyle: my rule now, if I cannot explain the diff, I do not ship it. Reading the code feels slow until the incident at 2am.
Girish: we should be checking the code, that is still on us. If you push back on anything, start there. He watches the console, hits escape, questions it. What helped him keep control: force the design to be more rigorous. Ask it to spell out the approach. Ask hard questions so you get a pre-sense of the change. Let the AI implement against something you already owned, instead of generating whatever it thinks it should. Does not fix a broken culture. Puts some of the thinking back in your hands.
maxzgx: he is slowing down more for memory retention and inserting himself back into the loop for steering. Otherwise you get a software factory where no one reads the code.
Tin Rabzelj: it feels better with Codex in plan mode on smaller focused sessions. He tries to avoid major work with /goal and splits it up, which is also easier to review. He does not think over-engineering and duplication will be fixed soon. The agent drills into one file and misses that the util already exists.
dharmafi: would not even call it struggling, but Codex over-engineers if you do not keep it on a short leash, especially on language design. He used Grok for high-level spec and Codex for implementation. Design conversation, checkpoint manager, implementation conversations. Manual, but it works better than one giant chat.
Benjamin Houy: the understanding gap. AI implements faster than his knowledge can catch up. He somewhat solved it with an explainer skill that explains decisions, architecture, history, then sends that to his e-reader.
Roman Mittermayr: spec, assign, carefully review, release. Honest that most reviews start feeling unnecessary, he does them less carefully, then it kills production and trust returns to square one. That is a warning more than a recipe.
Artem: I use Claude, I direct it, it mistakes my intent, I fix them. Force multiplier. Think, do not just press enter.
Thomas Fry, retired, still using Codex and Claude on personal projects: he could not imagine not reading every line and iterating. They produce horrible bloated inefficient code that works today and is spaghetti tomorrow.
Erik Aronesty: rebuilt a reporting engine in Go in three days, language he did not know, ran it in shadow mode until it matched, 250ms instead of 2.8s. The idea was his. Proof was the point. “Just have bigger ideas” only works if you still do the shadow-mode part.
Zane Kelly, on Armin’s question: trustworthy change management. Smaller verifiable steps, deterministic test gates, a human review surface that shows why changed, not just what.
Jeremy: he can trust 90%+ of the output but the remaining 10% is never the same thing, so he ends up trusting none of it. He wants a way to view the high-level work and validate in layers.
Someone else: an intent specification the agent cannot rewrite, because if it can rewrite the tests, the tests stop meaning anything.
Raoul: 5 hour window and compaction. He solved compaction with excessive log keeping. Still annoying.
How they would redesign the factory
This is the “it is not inevitable” camp. They are describing rooms that are not voxium’s.
Zane Kelly again, under voxium: the failure mode is measuring AI adoption in keystrokes. The guardrail is not another prompt. Small owned services, reviewable diffs, tests that fail loudly, an explicit stop-the-line owner. Shipping faster is not delivering sooner if the feedback loop is gone.
Pete Cooling: the real work is higher level. On his team, architects review PRs and write specs, both manually. They watch how pieces work and where the system breaks at seams. Creative work. They move faster. Big companies will be last because it needs a new org model.
Emily Hartstone: AI let her company grow. She is hiring more humans because of it. Their job is to read what the agents produce before it ships. Claude wrote a bigint sequence as string concat in her audit chain: 1, then 11, then 111. Failure swallowed, no alert. Caught only because she sat down and read it, in the part of the system whose job is proving what happened. After you have seen that, you stop treating review time as the thing slowing you down.
A small-company engineer: we try to keep a balance. LLM for discussions and for getting to a technical solution. Polish the result manually. Code review by other engineers.
full_kelly_: the companies that come out ahead will still give staff time to use LLMs as autocomplete, not for writing more than a few lines at a time. Full generation is how you know, deep down, you are developing debt rather than easing it. That is why the sense of victory is gone.
OneTweetAlone: loop engineering first. Then a reliable velocity metric tied to AI and business KPIs, so you can demonstrate there is a trade-off. Negotiate error budgets. Formal response. Reduce velocity to repay tech debt plus AI coding training.
Andor: typical management failure is assuming what shipped is perfect, with no independent quality assurance. Speeding up writing just speeds up issue delivery.
Manil: the problem is not Claude Code. It is multiplying change volume while keeping the same human review model. Review becomes theater, production becomes the test. Scrutiny should follow blast radius, dependencies, prior incidents, rollback. AI should reduce toil, not remove judgment.
Bill Staples: this is not the inevitable future. It is what happens when code becomes abundant without redesigning the software factory. He wrote a longer piece on a better version.
Shakil: nobody feels accomplishment because of how work is sliced. Every person should own a product end to end, that product only, instead of features.
david_zhang_sf: remaining job is three things. Verify product work. Design environments for agents. Talk to other humans.
Geoffrey Huntley, who said he has a bird’s eye: the technical challenge is verification of outcomes. Apart from that it is people. Most folks are not thinking expansive enough because AI is an identity erasure device. That is a senior naming the job, not a prompt trick.
Yared is building a graph IDE so you control the scope the agent sees: one function, its dependencies, docs, logs, tests, hide the rest. Walkthroughs of AI-generated work from the graph instead of scrolling the chat. Goal is not more code. Goal is humans staying involved.
Someone else in the same spirit: the problem is where the human sits. Downstream of a firehose is not engineering. You decide what “right” means. The machine checks.
A guild idea showed up: organize people who want bounded LLM usage, realistic velocity, not a joyless job for the people still responsible for the code. It was a question, not a union.
“Your company is the bug, not the model”
Tony Guinta: I lead an engineering team that uses agentic tools. I would never push them the way you describe. You are in a bad place.
ul90: the company is badly organized. LLM use is not the problem. Integrated correctly it is a benefit. I bet they were chaotic before AI.
Grady: this sounds like a place that would suck before LLMs. Engineering does not suck everywhere. Small company, executing better than ever, running circles around large orgs.
C. Gockel: leave. I know a whole bunch of coders whose jobs now involve reviewing AI-generated code before push, often with team review, because AI absolutely does fuck up. If they generate at this volume and nobody has time to understand it, they are heading toward a big fuckup. Get out before you get caught in it.
ezrakilty: you and your teammates have some power. Improve one practice. Make the day a little less onerous. Connect with other people who want something different. Form new teams. If enough people want it, it can change. voxium actually liked this one.
SpamRanger: leave. Interview first, get the offer, then give notice. Be discreet on the way out. Unscrupulous companies sabotage people who leave unhappy.
Ameripinionator, uglier and maybe accurate: when corporate strategy is let Claude do it and ship, you let Claude do it and ship. Until that strategy crashes it is policy. Anyone not implementing it will be viewed as the reason things are failing. Will the place blow up? Yes. Can you stop it? Nope. Enjoy the ride.
tonygentilcore: I would not worry about the industry overall. The company operating that way will not be around too long.
Foxfire: enjoy the ride, take the checks, watch it crash.
Keep the brain / leave the seat
Leetcode and side projects to stay sharp. That came from more than one person who used to take pride in the work. Freelance and consulting, not going back. Pivot to hardware, C++, robotics, chip design, because that has more years before the same thing lands. One person: I stopped caring, I tell them where it will break so I can have the I-told-you-so.
Justin Rogers, one-person startup, from the other direction: at that velocity your brain tweaks out, nobody has enough ideas to keep a whole company shipping like this, go look at customers and A/B tests, you will not beat the model at finding bugs by staring at the file. That is a senior who still owns the outcome talking. Different seat than voxium.
They did not agree
There is no senior consensus that “stop using AI” is the move. Three camps:
Stay in the loop. Read. Spec first. Shadow-mode the scary rewrite. Explain the diff or it does not ship.
Climb a layer. Bigger ideas, product, customers, architecture. Stop fetishizing files. This only works if you still own the result.
Exit. Quit, wait for the crash, switch industry, take the paycheck and detach.
The first two bounce off voxium’s room because that room allows neither ownership of the file nor ownership of the outcome. You are the name on the merge and not the mind on it. That is why so many senior tips sound true and still feel useless there.
What a junior can steal without waiting for a new org: own the spec before the agent runs, keep diffs small enough to explain, do not let the same chat grade itself, insert yourself back in on purpose, share what you do not understand, and if they forbid looking, it is not a prompting problem. Pai would add: do not disappear trying to look fast. The next section is me turning that into a daily thing. It is not a replacement for what they said. It is the compressed version I can actually run.
What is not a solution
Waiting for the next model to make review unnecessary. The voxium company is what you get if you believe that. Opus 6 will not sit in the blameless postmortem for you.
Reading every line of a four-thousand-line agent PR until you hate yourself, then rubber-stamping it anyway. You will lie. The lie is the job then.
Prompting harder as a personality. The people who are okay are not better at adjectives. They own a smaller surface and they check it.
Quitting on week two of one bad team and deciding the whole industry is dead. Some teams are not like this. Some are. You have to look, not generalize from the worst room you have been in. Also do not generalize from Twitter that every shop is a monastery. It is not.
Pretending pride will return if you just accept your new identity as an orchestrator. Maybe it will, for some people. A lot of the “just have bigger ideas” replies were from people who still choose the idea and still read the scary parts. They are not enter-pressers. Do not let them confuse you.
Building a union of “bounded LLM usage” is a nice thought that showed up in the thread. I cannot start that from a junior seat this month. I can do the smaller things below without waiting for a guild.
What to actually do
The last section is what they said. This one is me, junior, turning the overlap into something I can run on a Tuesday. I cannot fix the company from this seat. I can pick where I sit in the loop, and I can build the scars on purpose that seniors got by accident. Not “catch up to 2016.” Not “become a prompt genius.” Become someone who can still tell whether the output is right, in at least one corner, out loud, with the chat closed.
Where a human still has to sit
I decide what done means. Not the model. A sentence: this should happen, this must not happen, this is how we will know. If I did not write that, I am not directing anything. I am approving a story. Girish said it in the thread: force the design first, ask hard questions, implement against something you already owned, watch the console, hit escape. That is not nostalgia. That is staying in the loop.
I do not let the same chat write the change and the proof. A test I wrote, a fixture I looked at, a click-through on the money path, a metric, something the model is not allowed to quietly edit so it can go home. Independent check. Without that, Claude is grading Claude. That is the pipeline voxium described. I do not want that to be my career.
I stay close when we are making or breaking primitives: the interfaces, the data, auth, billing, migrations, anything you cannot reverse at 2am. I can be lazier inside a box that already exists. If I am lazy about the box, I will spend the next year asking the model where the box went. Kent already said this. I am repeating it because I need to hear it every week.
After a change I can explain in a few lines, in my words, with the chat closed: what changed, why, what it might break, how I would debug it. If I cannot, I did not ship it. I forwarded it. kyle’s rule from the thread: if I cannot explain the diff, I do not ship it.
One or two agents, not five. Parallelism is how you get the RTS feeling and no memory. People who sounded intact were not running a factory. They were running a tight loop they could still feel.
How a junior evolves when the ladder started in mid-air
Seniors remember files because they typed them. I will not get ten years of that, and I should not pretend a toy Todo app in vanilla JS is going to simulate 2016. I need a compressed version of the same education: being wrong, reading, owning a small thing end to end, and saying no when something smells. The unfair part is I have to do that on purpose, in the cracks, while the job tries to train it out of me. Seniors could get paid to learn it. I might get paid to skip it.
Own one corner. Not “the backend.” One service, one workflow, one gnarly module. I read it without an agent. I can draw it. When the model touches it, I notice. Breadth is how juniors fake seniority. Depth is how you stop being a proxy. If L1 and L7 look the same from above, the only way I look different is I actually know a piece of ground.
Do the 0 to 1 somewhere, even if work forbids it. A side project I cannot one-shot. Something I have to live with for weeks. When the agent implements a piece, I rebuild one piece by hand afterward, or I write the failing test first, myself. The point is not purity. The point is a memory of how it is put together. People keeping leetcode and side projects to stay sharp are not being romantic. They are doing rehab.
Learn to read diffs like that is the craft. Because it is, now, whether we like it or not. Not skim. What would I have named this. What is extra. What line would never occur to a person. Armin’s thread kept describing that one insane line in a sea of fine code. Finding it is a skill. I only get it by looking. If work is a firehose, I pick one PR a day and actually read it, including mine.
Steal scars from production, not from Twitter. When something breaks, I follow it further than the agent summary. What was the actual state. Why did the test not catch it. If nobody on the team does incident notes, I write a short one for myself. The bigint-as-string story is the kind of scar that makes you refuse rubber stamps. I need those. I will not get them from launch tweets.
Use seniors for why, not for prompts. If I ask them how they would phrase the request I learn to be a better meat proxy. If I ask why this boundary exists, why this is scary, what they would not delegate, I get the thing I skipped. Their value in this era is the library of no’s.
Do not fake it in standup. Pai’s death spiral starts with “going well.” The junior version is “the agent is on it.” Say what you do not understand. That is embarrassing in a ship-fast room. It is also the only way anyone can tell you are still in the room. Sharing work is how you do not disappear. Disappearing is how you get cooked quietly.
Be useful in the ugly work. Tickets nobody wants. The bug that has been sitting there. Docs that are wrong. The extra AI diagrams that mean the wrong thing. That is how you learn a codebase when you were not allowed to write it. It is also how you get trusted with something bigger. Pai is right about this and it is not glamorous enough for X, which is why it works.
Keep a private scoreboard that is not lines merged. Could I explain last week’s change. Did I catch something the model missed. Did I shrink a diff instead of growing it. Did I say no. If the company only counts merges, they will train me to be the problem I am describing. Their dashboard is not my education.
Accept that some pride has to move. I may not get “I wrote this file.” I can still get “I can defend this behavior” and “I caught the thing that would have paged us.” If I need the first kind of pride, I take it on the side project. If I wait for the job to give it back, I will wait in a room that is trying to extinguish it.
If the room is voxium’s room
I try, once, to buy review time on the dangerous paths, with an example, not a rant. A swallowed error. A test the model rewrote. A PR the author did not read. If the answer is still just ship, I stop trying to save the strategy. There were people in the thread who said: do what they told you, it will crash, you cannot stop it, do not be the person they blame. That is ugly and sometimes accurate. I do the job they are paying for without feeding it my whole mind. I learn on the side. I look for a team that still wants a human on the hood.
Leaving is allowed. So is staying for the paycheck while I build a corner they cannot see. What is not allowed, if I want to still be an engineer in five years, is becoming someone who cannot tell whether the output is right. That is the actual cooked ending. Not “AI exists.” Me, empty, confident, merge.
I do not think the profession ended. I think the easy story of how you become one did. Seniors walked a road that was the job. For me the road is a thing I have to build on purpose, in the cracks, while a model talks all day like it already knows. The people who sounded okay in those threads were not the ones who typed fastest. They were the ones who still had a place where they could be wrong, notice, and remember. I want that more than I want to look busy.
Top comments (0)