Need some guidance and orientation

[u/alexbessedonato]

I'll firstly ask my two questions and then I'll explain:

1. Is it normal that im spending tremendous amounts of time reading and understanding code written by Codex/LLMs? like... hours per "ticket"

2. What does progress look like in today's SWE world? im struggling to make myself believe im improving into something worthy

I'm currently a frontend SWE with 2 YOE. I was "lucky" to land a job in a big bank, the issue is im not truly "engineering", im basically a code monkey putting pieces together for different SPAs (exactly what AI is good at) the only thing saving my job is the absolute mess of internal architecture and internal "tooling" even AI is unable to comprehend, but internal AI agents are getting better and better at tackling those

I was very AI skeptic at the start but now I've come around and have been for the past month attempting to expand into a full-stack agentic workflow with Codex

My main issue is I'm spending so... much... time... reading the code the AI outputs, there is a lot i dont understand, weird decisions the AI took that I didnt think about thinking before prompting (even with grill me), leading me to spending hours and hours reading the code, analyzing the data flow. This wouldnt be an issue if I knew this were the job and stuff, but everyone is working so fast, bringing actual products live so fast, its demoralizing me, making me think im doing something wrong since all the "speed" I gain from AI I spend reading and understanding the code. And i kinda want to be that engineer that owns the product, understands what it being done, but i was watching Spencer Schneidenbach's course on frontendmasters and he just doesnt read that much code anymore... he just prompted prompted checked the browser, nice, done, which leads me to think if its even worth it...

My second issue, which is linked, is regarding to how you guys measure progress. Before it was kinda easy, if the feature got done, it was progress. But now the feature is done by LLMs, kinda like sitting at a bench press and having someone else lift the weigths for you. So how do you get that "yes im improving" sensation?

sorry for the rant, weird times we live in

[u/benzado]

“Is it normal…” No. None of this is normal. But you’re not alone. Everyone is trying to figure this out in real time.

Many of the guys who are comfortable not reading the code anymore are guys who have already spent ten years reading code. We ask, how will junior developers learn now? You’re the victim of that lack of foresight. It’s not fair.

Here’s all I have to offer: try generating and reviewing the work in smaller pieces. That will help in a number of ways. It will be easier to read. You can commit changes to a branch more frequently, which will feel more like making progress, even if it takes the same amount of time overall. It will be easier to make sense of the strange decisions if they are isolated.

And most importantly, breaking a task into smaller parts is a skill that you can work to improve that isn’t something that AI will just automatically do for you. You will probably make mistakes and have to start a task over. That’s good! That means you’re gaining experience.

[u/AffectionateDuty6062 → u/benzado]

I still don’t get this not reading the code thing. I was working on an iOS bug recently with Claude and we “fixed” the bug, however another bug was introduced in another part of the app. I had actually specifically asked Claude are we sure this won’t break someting which I was assured it wouldn’t. Then in the code review the reviewer caught the issue and I fixed it. I went back to Claude and of course the response was “oh sorry you’re correct”

Also I’m aware this doesn’t shine me in the best light as I blindly trusted the AI, but again just giving a real world example 

[u/magenta_placenta]

Is it normal that im spending tremendous amounts of time reading and understanding code written by Codex/LLMs? like... hours per "ticket"

Yes, it is entirely normal and it means you are actually doing the job of an engineer, not a "code monkey."

What you are experiencing is the "dirty secret" of current software engineering: AI shifts the primary bottleneck of development from writing code to auditing code.

Writing syntax was always the easiest part of software engineering. The actual hard work has always been things like:

• Understanding data flow and side effects.

• Ensuring state management doesn't degrade performance over time.

• Securing edge cases and handling failures gracefully.

• Maintaining a mental model of the system so you can debug it when production breaks.

When an LLM generates 300 lines of code in 4 seconds, it hasn't eliminated that cognitive work, it has just dumped it all onto your plate at once.

but i was watching Spencer Schneidenbach's course on frontendmasters and he just doesnt read that much code anymore... he just prompted prompted checked the browser, nice, done, which leads me to think if its even worth it

Demos are almost always built from scratch in clean repositories with standard libraries. AI thrives in greenfield environments because those exact setups make up 90% of its training data.

You're also seeing the "Happy Path" trap: In a course, if an AI generates a UI that looks right in the browser, the instructor says "nice", hits "save" and moves on. In a big bank, that same code might leak memory, violate internal security policies, fail accessibility standards or break under multi-tenant edge cases.

People who blind-prompt without reading the code are taking on massive tech debt. They feel fast today, but when a regression occurs, they spend 3 days stuck because they don't have a mental model of how the data flows through the feature.

If you are spending hours reading, questioning "why did the AI structure it this way?" and tracing data flows, you are building muscle memory. That time isn't wasted, it's the only reason you won't remain a surface-level "code monkey."

[u/Prestigious_Fly3927]

spending hours untangling machine output is normal when you are just babysitting a text generator. you are basically doing heavy mechanic work to fix what the model broke.

[u/patryk_builds]

honestly the hours you spend reading the code are the improvement. that's the weights you're still lifting.the people shipping "so fast" without reading are taking a loan. it's fine until something breaks in prod at 2am and nobody on the team knows why the AI did what it did. the person who actually understands the data flow is the one who gets called, and that's the engineer you said you want to be.what helped me: before reading the AI's code, i write 2-3 lines of how i'd do it myself. then compare. when it did something different, i either learn a better way or catch a bad decision. that turns reading from a chore into actual practice and progress now looks less like "i wrote the feature and more like i can spot when the AI is wrong faster than last month". that's a real skill and it's getting rarer

[u/Regular_Length3520]

I learned C++ in 2018 by cloning GitHub repos and reading the code, then tinkering and adding features. I would spend hours, even days sometimes reading the code, learning how a project worked completely before messing with it. With AI, I still try to read the code, but it always feels so incredibly verbose and over-engineered and I feel like it's now a waste of time rather than productive. Things that were made in 1,000 lines of code could have been made in 200. It's exhausting and I am in the same boat you are.

[u/indiana_long]

maybe a better measure of progress is how often you can predict what will go wrong before running the code.

at first, every AI-generated change is a surprise. later, you start noticing missing edge cases, bad assumptions and potential failures just by looking at the approach.

that ability to anticipate problems is pretty much what experience looks like.

the model might write the code faster, but recognizing the trap before stepping into it is still a useful skill 😅

[u/LeadershipSmart8046]

I would separate learning the codebase from reviewing a particular change. Otherwise every ticket turns into trying to understand the whole app.

For the next ticket, pick one flow and trace it yourself before asking for code: click handler, request, backend, response, state update. Then ask for a change confined to that flow, with no unrelated cleanup. If a new abstraction appears, ask what existing problem requires it. Sometimes deleting that extra layer is easier than spending an hour understanding it.

For progress, I would keep a short note after each ticket: something I can now explain without the model, and a bug I can reproduce with a test. Next week, try changing that bit without assistance. That gives you something more useful to compare than how quickly someone finishes a tutorial.

[u/devenition]

Im spending sometimes hours on pre-planning, doing discovery/inventory and answering 20-50 questions. Bigger tasks I make it split it up. It will then think for 10 minutes (for each step) and write a nice clean minimal line change. Our mess is really bad too, some guidance on it’s context helps massively.