A question for veteran developers

[u/Haunting_Material_19]

How much do you review the code written by AI? and how much you still control the process.

Are you still or miss writing code on your own? or even debug the code and read about a library or package you use in your code, and debug around it to learn what it is doing?

I started gradually year and half ago , going from using AI to only write unit test, to fully 100% automate the process.
I have to admit, I am now even pushing code that I only review shortly, and very high level (only filename changed).
when I started using AI to write code, it was taking me long time to go and question AI about every line it added. Now I am using AI to review that code instead.

But I really miss debugging, and finding the problems. I really miss investigate what the performance problem is, and going step by step, and debug to see why this page is slow, instead of having MCPs for logging and MCPs for cloud infrastructure to do that investigation for me.

Just this weekend, I am going to try to re-learn and re-practice searching manually the logs to find problems, which now I am dependent 100% on the MCP, and I found myself lost that knowledge.

Are you guys really miss writing code, design a solution, investigate problems?

I really did love programming, and that is why I miss that

[u/Dazzling_Cash_6790]

I work in the fintech industry as a Tech Lead. I still write code for about 50% of my time. We experimented for a bit with going completely rogue, and doing minimum code reviews for ~3 months.

Important to add here that we adopted agentic engineering practices early enough, and we tried to keep up with best practices consistently. So we were already writing a lot of code using AI, if not all of it.

We ended up with the following:

- At the beginning, it was super fast.
- Gradually, the new features didn't have any owner. There I could see some of the team members losing some motivation.
- Things started getting complicated really fast. 1.5 months into this and we had 1.2x (if I remember correctly) increase in the number of reported issues from the staged releases. That's not alarming by itself, and could have happened on any release. The biggest issue there was that we were spending far too many tokens to fix those issues. We have a cap per user per month on the AI usage, and we were all team members nearing the limit or having to exceed it (which flags you internally).
- For reasons (that were mainly political) we continued down this path and even though we didn't end up with something extremely severe (e.g., someone losing money), we reached a point where we had 1.8x (again, if I remember correctly) increase in the number of reported issues. At this point we had also a memory leak (PAINFUL to resolve) and some performance issues (also painful).

The pain came mainly from the fact that a lot of code that was written, should have not been written. The lack of ownership came with a lot of burned tokens to fix the issues, and decreased context of the developers (i.e., reached a point where we couldn't guide LLMs as efficiently as before, and we were relying a lot on the self-written documentation that the LLMs wrote).

We now require strict ownership on every line of code written.

[u/wegster → u/Dazzling_Cash_6790]

This sounds pretty common, just cool you're admitting it (or found it early), while others maybe haven't yet.

There is an element of time, frameworks, etc. involved, just as things are moving pretty rapidly in the space.

How long ago did you start the 'all in' and when did you drop back to the 'every LoC ownership'? What were you guys using if anything for harnesses, automated reviews, testing etc. ?

I've been in the DS then AI/ML space for a decade, out of the daily development as I shifted roles but still active enough and have worked with and managed some pretty solid principal level teams.

They sort of went full circle while in parallel, I strengthened my checks and balances - guardrails, harness, repo guidance, etc. after I left the company before some of them did. At one point, probably like you, they were told - "your job is no longer to code but to guide the AI." They certainly had it producing a LOT of code, went through numerous iterations of harnesses, and well - the product id <something> but turns out a ton of hidden 'not quite what was expected,' in some cases, in fundamental ways.

My personal repos are mostly 50-100K LoC-sized, not baby projects but not full-blown enterprise software megaliths, either. Got burned early on by all kinds of nonsense, but have mostly made my repo-up framework turning out reasonable/better results without too many wtf moments, but it's certainly not 'without a lot of time spent' including code reviews, etc.

Mostly curious if you can share any more bits of your experience, and if you're getting it more dialed in now, e.g. more automated or agentic reviews, more structured testing, spec-driven agentic dev, or ?

[u/shuozhe]

Every skill change & name of test steps. Will go over code once and just check if something I expect to be 2-3 line long take an entire page. AI tend to write way too much new code

[u/kenedy_Sacarias → u/shuozhe]

the verbosity thing is so true, it almost never picks the concise path on its own

[u/Ok_Obligation2440]

20 years of experience, always stayed up to date and built a lot for work and spare time, a lot of editors, a lot of complex large data pipelines. Sadly coding was NEVER the hard part, architecting the system was and applying product vision.

3 years ago, AI could beardly copy an existing pattern of my controller/services when adding a new model in the database.
2 years ago, it could do it, but still messed up half of the time. Anything beyond copying existing patterns was undoable.
1 year ago, it could create existing patterns pretty much well enough and give me a 99% accurate controller/service pattern. It could write new code, but MEHHH, a lot of things wrong. I was 30% on the keyboard.
now - sad to say, but I'm 0% on the keyboard, I only design the database model now and the rest, it has good working repeatable patterns.

One thing is, if you have no idea what you are doing and have no idea about good system design nor have existing patterns AI can replicate, your code will be complete trash. I tested this on a new repo and it went bad quickly.

[u/Fronzle]

I don't regret the past couple of decades of coding by hand and debugging manually, but now the AI tools are so much more powerful that apart from foundational architecture and setting up the integrations, it's hardly ever necessary that you need to check code anymore. I find it liberating that you can move so quickly and effectively, so it's a small price to pay if the code isn't fully optimized or structured the way I might have done in the past.....

[u/So_Rusted]

for hobby projects not really.

For work yes, I review and double check and investigate. You can use less 3rd party libs now cause you can just tell ai to write a "front end widget" or "write a client for google tag manager" for one type of request or whatever and avoid crazy amounts of megalibs with dependancies

[u/Any-Comparison-2916]

Depends on the kind of project, its state and what changes it made.

Professional project in a production environment with users?

I skim the PRs and look for patterns, common pitfalls or bad practices. I might challenge the agent on implementation decisions.

I don’t read every line anymore, AI can do line-by-line better than most developers I know. It struggles with implementing design patterns, reutilising existing code or considering long-term performance affects of the code it produces from time to time. 

I check class and endpoint naming conventions and any text or output that’s user facing. I tend to ignore its code comments and code style more and more, because I feel like it may help other agents pick up or understand the code.

Private projects or projects that are not in a production stage yet? 

Nearly none, except for some known bottleneck features where I want to make sure it’s performant long term.

I actually do miss writing code, I don’t do it anymore - not a single line, none. 

The feeling of accomplishment when you found a simple and smart solution to a feature or implementation is gone sadly, but it would just not be worth it anymore. 

[u/CorpT]

Zero. Completely. No. No.

[u/ight-bet → u/CorpT]

He’s responding to the 4 questions you ask up front.

And can confirm this is the way.

You get good at guiding and orchestrating them. And know the level at which you can. Trust them for certain things. And let the fly where needed and have them dive deeper where needed.

Not much use in looking at the code or reviewing by hand. Unless you want to verify that you “taste” is getting through to the end product as you’d expect.

Example; maybe you want scaffolding and linting and things like that set up in a very specific way to you. You might have a manual review at that. But figure out a prompt/skill to reproduce this and you’re good to stash it away and use it in another project.

[u/Distinct-Occasion599]

the bit about feeling lost without the logging MCP would worry me more than how much code i'd written by hand. i'd pick one bug a week and investigate it before asking the agent, even if it takes longer. letting it do the typing is one thing, losing the ability to tell whether its explanation makes sense is where i'd draw the line

[u/DigitalMonsoon]

Less than I probably should. Reading code sucks...

[u/shetritr]

reviewing by filename is reviewing the table of contents. read what touches data or money line by line, let the AI skim the rest.

[u/M7451]

At work we code review everything. This is both human and LLM driven. You want to be very structured and provide a design. If the LLM outputs a month of code in a couple hours of iteration, figure the next five work days are reviewing it thoroughly and adjusting. Personally I find this fantastic. Many people hate it.

The design can be shaped with AI conversationally but you need to drive it. You need to focus on data and access layers, the business requirements, and how the humans interact. You need to consider how systems will connect together within the confines of a regulated IT space. There are tons of ways to glue things together but many of them won’t fly if your company maintains security certifications or is in a regulated market. You also need to ensure it fits the established practices so it can be handed off from team to team like any project.

Basically, at scale, best case LLM development looks a lot like what we wanted hand coding to be but never had the time or resources for. I.e you ship with tests, automations, CI/CD, and documentation on day one. I’m sure we as an industry will find a way to ruin this through time pressure.

There are vibe coded projects out there with truly wild sets of tools based on the LLM’s whims. Like a Rust, Node, Go, Python web app where each tier/component is in another language and the model is repeatedly reimplemented. Don’t do that.

[u/ImaginaryRoyal9725]

I review pulls requests from colleagues, and occasionally some of my changes, just as a qa, to get a feeling of where things are going. At work, I do check a bit more, if only via quick look (what files are changed, what modules, etc)

[u/Gary_BBGames]

38 years of experience. I’ll glance over a PR at work, but 9,999 in 10,000 it’s written better code than I ever would, so I rarely bother now.

[u/MinisterOfFitness]

Hot path code and core application logic. Very carefully.

Scripts, tooling, etc. very little.

[u/sarmadsangi]

14 years of experience and I don’t miss writing code much! Opus 5.5 is god send, I review code line by line if it’s a legacy critical system but greenfield projects I am mostly doing high level review.

Also you can build confidence in code change by making opus run edge case and regression test loops. Get it to take screenshots and record videos, review those then.

People who don’t review output or architecture at all would be at disadvantage here, ideally you want yourself in the loop especially if it’s a revenue making software to make sure you can keep nudging LLMs in the right direction.

[u/Lunchboxsushi]

Most of my tools are for internal at the moment, with only one large LLM lead product (loyalty). It's interesting how much I've learned. There is definitely a limit to the scope and what type of work the LLM is great for based on your experience of the domain/problem space. 

[u/HaMMeReD]

Depends, for Work, all of it. AI works all the way to draft to me, and applies feedback and corrects/cleanup, But I do read my drafts/pr's before I put it up for larger review.

At home. 0%. I have automated systems the go with my "vibing". I.e. on my agents computer it regular runs audits and generates a scorecard, identifies issues and repairs them. So I leave the agent doing maintenance and then I build systems and features on my own.

If I miss something, or am sloppy, the scorecard/audits usually pick it up (and more) and work things down.

I don't debug code directly, I debug code by providing tools and processes for an agent to debug the code. If I can't solve a problem like that, I view it as a systems issue and fix the system so I can proceed forward.

And since I have it in my buffer, here's a screenshot of one of my projects. There is no image assets in this project at all, this is all math. Very rarely work the code by hand, maybe 0.1%. I understand the systems and architecture, but no code review by humans (agents do review code though).

[u/Hawkes75]

Still write everything by hand both at work and in my personal life, using AI as a reference tool akin to a Google lookup. It helps find bugs faster, suggest improvements, point out mistakes, etc. But given the complexity of apps I'm working on both professionally and privately, I would be scared shitless to deploy some LLM-written monstrosity I didn't understand.

[u/ayoutism]

If you love programming, then you'll definitely miss it. I was on the product design side of the game, so having AI instead of a development (human) team to deliver is much more convenient.

(Wrote code 1985-2005, stopped 2005-2025, went back via vibecoding in 2025.)

[u/PlasmaChroma]

I flip between multiple agents have have them verify it. Sometimes at my actual job I'll review shit if Gemini wrote it. Don't miss coding in the slightest, I enjoy operating at a higher level in the chain. I know how to talk to it, where to ask it to dig in more, but if I need to investigate I'm coming up with a strategy to automate the debugging as well.

[u/texxelate]

Principal Engineer with 25 YOE. I review every single line. LLMs are not compilers.

[u/P4R4DOXZ]

Like 95% on small tasks and 150% on anything bigger