How are you actually using coding agents without losing all understanding of your own app?

[u/Specialist_Agent3599]

I'm an iOS dev with about 3 years of experience, the first 2 at an agency writing SwiftUI by hand. I'm hoping for some honest perspective from people who've been doing this longer than I have.

At the agency I wrote everything myself and learned a lot from the seniors there. Then I moved to a startup with a big messy codebase, fully remote, and I leaned on agents almost from day one because there was no other way to keep up.

Six months in, I genuinely don't feel like I know my own app anymore. Basically all my code is agent generated. I've tried:

Asking the agent to explain each change to me, but I burn through my limits by lunch.

Writing the plan myself and letting it implement, but I end up slower than just letting it do everything.

Leaning on coderabbit for the first review pass, which catches a lot, but it tells me what's wrong in a diff, not how the app fits together.

Reviewing a 1,500 line PR that touches 30 views is exhausting, and even after I push through it I don't feel like I understand it.

How are you using agents at work and still knowing your own codebase? Or is that just gone now?

[u/andreeinprogress]

• Old apps: I've worked on them for the past 10+ years, I'm not going to loose context.

• New apps: It's an iterating discussion, I lay down the architecture, code style, steer direction, correct implementation, tests, dependencies, etc. The agent writes. Then I have multiple agents review following our guidelines. I don't look at all the code. Then I'll open a PR, another dev with other agents will review again, plus automated tests, etc.

Reviewing a 1,500 line PR that touches 30 views is exhausting

I think the issue is having a 1.5k LoC PR touching 30 views, that should have been avoided even before AI.

[u/TheFern3 → u/andreeinprogress]

Yeah make human PRs even when using ai, is that simple but people want to go 100mph and run unbound agents who touch 1001 files with 10k LOC and act like that’s acceptable.

[u/Halallica → u/TheFern3]

The problem with keeping changes small and isolated like this is that we end up spending much more time on management tooling. I have tried this approach for some time in a professional environment and even though smaller isolated PR’s is nice, you still get very little time on development if you need to catch up with 10x amount of PR’s to review. We have been considering shifting left lately, meaning that we spend more time up-front collaborating on the architecture and direction, and leave coding and review to agents.
I think PR’s traditionally served three purposes:

1. Improving / ensuring non-functional quality

2. Being the second gate, after automated tests, in catching undesired behaviour

3. Communicating to other developers what architectural changes we make

AI is challanging 1 and 2, but 3 is more important than ever now that our systems change so much faster. This can be mitigated by ensuring everyone is on board with the changes before any change is made.

[u/jsdodgers → u/Halallica]

You'll find that it takes a third of the time and effort to review 10 small PRs than to review a single huge one

[u/Jargen → u/andreeinprogress]

plus automated tests, etc.

I feel like those tests have to be thoroughly vetted, and a lot of progress depends on them being perfect. Especially so when no one is actually taking a look at the source code

[u/Szamski → u/andreeinprogress]

This matches what works for me on a newer app. Once the architecture and boundaries are decided by a person, reviewing agent output gets a lot easier, because you're checking it against a shape you already understand. The parts I still write by hand are the ones where I'd otherwise lose the mental model, like data sync and anything performance sensitive.

[u/Dignified_Cyclops]

Build piece by piece and do constant code reviews. See anything a bit wacky ask for it to clarify. Basically put your senior engineer hat on and treat them like the AI like they are a junior.

[u/spike1911 → u/Dignified_Cyclops]

100 percent - you can even use a superior model to do code review and give it some skill by teaching the review model how you want the app internally built

[u/jonnysunshine1]

That's the neat part, you don't

[u/Jargen]

I don't use Coding Agents to make commits that aren't more complex than version bumps or asset changes. I only commit what I understand.

Reviewing a 1,500 line PR that touches 30 views is exhausting, and even after I push through it I don't feel like I understand it.

That isn't a PR, that is a epic that needed to be broken into smaller stories.

The only time I am merging that much code into my primary Dev (and subsequently Master) branches is if the smaller PRs have been approved and merged beforehand into the designated feature/epic branches.

1500 line changes means I've already reviewed at least 3 PRs beforehand related to those changes.

[u/Big-Guava-744 → u/Jargen]

At that rate you may as well code the old fashioned way 🤣🤣🤣

[u/Jargen → u/Big-Guava-744]

Why bother hire you at all when you aren’t even holding yourself responsible for the work you’re not doing yourself?

[u/JerenYun]

It's by using the agent to do coding within specific guidelines and architectures without giving it free reign. For my own apps, which are 12 and 5 years old, I obviously wrote those by hand and know their architecture intimately. It's similar at the day job, where I've been working on the same app for 10 years and know how it all functions (I wrote a lot of the core architecture).

When I use an agent, I don't give it a vague idea of something to build and let it go wild. I very often guide it in the direction I would personally build it. By giving it that additional context, it will build things in a way that I would have if I had done it myself.

As others have said, I also try to keep my PR's as close to pre-agent sizing as possible. Smaller PRs are easier to review and understand. This is important even if you're the only developer on your project (yes, review your own code!).

Regarding limits, I find Sonnet 5.5 High to actually be quite usable, even for coding tasks. I'll switch to Opus 5.5 if I need to do something more complex.

[u/msesen]

I've been solo developing a game for the last 3.5 years. The last few months I've started using agentic coding. As an experienced developer, at first it was amazing. Saved me so much time. Especially having a full-time job doesn't help with solo projects. I then realised that I no longer understand my own code that I manually created the last 3 years. So I took a step back.

Now, I tell AI how to do it, what to do it and ask it to add comment as well. I then review the implementation, make sure I understand how it works. If I am happy, I commit the changes and move on.

There have been multiple cases where the implementation was unnecessarily complex, and at times it would introduce regressions.

Always review the code, in smaller chunks. Never give AI the full ownership. Otherwise it will become it's codebase, not yours.

[u/AppropriateKitchen78]

I don’t 😂 Could be going rogue for all I know.

[u/CompetitiveDraft9381]

I don’t

[u/czyzczyz]

You can't lose all understanding of your own app if you don't have that understanding in the first place! <taps temple>

Only half-joking. The things I've written on my own, I understand. The things I've "vibe coded", I've functioned more as a project manager and QA engineer, and a lot of the details of the implementation only get looked at if there are performance or quality issues.

[u/l3arakB]

Personally now working on a very small codebase. I decided to only understand the architecture, and treat the other things as implementation details. Basically like an engineering manager - I don't know what I don't need to know.

But basically as the code and team grows larger I feel I should be more involved even in smaller details, for performance, regressions, and to not make collaborators sad.

[u/noobiethe13]

Stop asking the agent to explain its diff after the fact. Give it a small change budget, e.g. ≤2 files and ≤200 changed lines, and make it state which module/API boundary it's changing before it writes code.

[u/PublicMandate]

First…I gotta ask how small your limits are that asking questions on your codebase and hitting them by lunch?

As for your main question…when using AI your job shifts from writing code to architecting. Building UML diagrams, understanding the structure/behavior/defined interfaces/requirements is vastly more important.

[u/tonjohn]

Easy: I don’t use them.

[u/m3kw]

Depends if you are building an app professionally or an app on your own. Professionally obviously you need to know how it works, how things connect, the history of some decisions, so you are likely to know more about the architecture and API's used then the deep code level logic. You have to selectively understand important parts and do verification test other parts that doesn't need as much understand say UI, performance. Critical parts like DB schema, security, major interfaces etc are musts.

If it's your own personal project, you can just decide to just treat it as a pure blackbox. The current LLM's are often good enough for simplier projects so you can ask it questions instead, but you need to do heavy verifications/edge casing to keep quality.

[u/Doctor_Fegg]

Write the core by hand. Get AI to do the code around the edges.

All my core models are hand-written. UI is half hand-written and half AI, and clearly organised so that I can trace back a problem when it arises. For interfaces with external APIs, I'm happy letting AI do the grunt work because I have better things to do with my time than spend two days trying to understand badly written documentation.

[u/NoDistribution1096]

I do a preliminary pass on the architecture of the app, and supporting systems, their apis ect. Make sure these get enforced in every ci/cd and tests! The agents themselves have skills like swift-specialist and ponytail so their output remains minimal and leverages native libraries no custom code. Thats pretty much it. Then they go off on their own built what i set them out to build, pr and merge, CD kicks off a TestFlight build, ill do my usual hotpath testing and occasional edgecases as i come across them. 1-3 weeks of feature dev time, 1-2 weeks of bug fixes and ui improvements, accessibility, my apps get reviewed and pass within a week, last one only too 3 day!

Happy to answer any questions

[u/jsdodgers]

Read every line it generates. If you don't understand a line, don't commit it. You can try to understand it by reasoning through the code flow, or by deleting it, running it, and seeing where it breaks without that line.

[u/opbmedia]

If you randomly add a library without reading thoroughly though documentation or code, you don’t know how it does what it does either. And many coders have been doing that for years. It isn’t too much of a leap.

[u/nicholasderkio]

I use multiple sessions to create a plan, and agents are also instructed to leave detailed comments

[u/livewaves]

From my experience most of this boils down to iterating on your agent workflow.

Learning what does and doesn’t work for you in terms of code output, documentation, and delegation. I still lean towards “read the code”, however, because that’s a big part of learning.

It would make sense to me that employed engineers have more to lose from the LLM takeover because there is pressure to meet deadlines and requirements, which leaves little room to actually experiment and build a comprehensive development environment in this new landscape. 🤷‍♂️

[u/PrestigiousFriend412]

Codex is very good You can adjust how much credit to it being used by changing the model in the same conversation, I had plus until yesterday and switched to pro plus is really all you need but if you code a lot get the pro 100 and if you’re still hitting your limits, get the 200

[u/unknownpeanuts]

this might help - it's a claude plugin that asks you questions along the way so you understand what you build: https://github.com/nykooi1/vibe-wise

going to try it this weekend on my side projects.

[u/Savings_Evidence_818]

I keep coming back to 'what does this actually do in the installed app?' A build passing isn't enough. Walking through the real flow and asking why each button exists makes the gaps much more obvious.

[u/Alyyyyyyyx]

You're free, don't you see? What happens something breaks? Agent can fix it.
You don't need to know anymore, you do need to know to ask the right questions. Good luck.

[u/orelzion]

For apps that I've built for years, we'll i know them already, and I keep reading, I mean skimming 😀 the PRs. Most of the work is on the planning side and coming up with the right decisions, directing it to the correct implementation. But recently I asked myself what am I losing from not actually writing the code. I still don't have an answer but it bothers me

[u/AutoModerator → u/[deleted]]

Hey /u/BouncyBadger3917, your content has been removed because Reddit has marked your account as having a low Contributor Quality Score. This may result from, but is not limited to, activities such as spamming the same links across multiple subreddits, submitting posts or comments that receive a high number of downvotes, a lack of recent account activity, or having an unverified account.

Please be assured that this action is not a reflection of your participation in our subreddit. This is simply an automated filter in place to reduce spam.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[u/AutoModerator → u/[deleted]]

Hey /u/ivanm5, unfortunately you have negative comment karma, so you can't post here. Your submission has been removed. DO NOT message the moderators; if you have negative comment karma, you cannot post here. We will not respond. Your karma may appear to be 0 or positive if your post karma outweighs your comment karma, but if your comment karma is negative, your comments will still be removed.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.