Code

Coming Back to Angular in a Million-Line Codebase

Three years into ClickUp, looking back on relearning Angular after React inside a million-line codebase, and how agentic tools changed debugging, docs, and onboarding once the map stopped living only in my head.

Three years at ClickUp is what spurred this post.

When I arrived, the codebase was already past a million lines, and I was coming back into Angular after three years in React, so I was learning the wheel again inside a system that large without AI, which felt like a chore that ate the whole day before I had written anything useful. The investigation loop took enormous brain space just to find where to start, which file owned the behavior I was looking at, how the Angular patterns in this house differed from the React muscle I still carried, and how to make a fix that would not surprise three other systems I had not met yet.

That friction was not a failure of curiosity so much as the cost of holding a map that large in working memory while still trying to ship, and for a long time the only way through was grinding: search, skim, ask a teammate, search again, and hope the next stack trace pointed somewhere honest.

Context shows up before the hunt

Agentic tools have changed that loop more than any onboarding doc ever did for me, because they surface critical context up front instead of waiting for me to discover it by accident. I can describe the symptom, point at a task or a failing path, and get back the likely owners, the related flows, and the places where a similar fix already landed, which turns debugging from a reactive hunt into a decision about which of a few concrete options is the right one.

I still have to choose, and I still have to verify, since the agent gathers and drafts while I decide, but the expensive part of getting oriented no longer has to happen entirely inside my head. The catch is that an answer only helps if I know what to ask, because a vague prompt into a million-line system is still the blind leading the blind, and the agent will confidently walk you somewhere that looks plausible until you can tell that it missed the room you actually needed. The same pattern shows up when I direct the agent and review small stacked pull requests, because staying oriented is the job once the first draft is no longer typed by hand.

Documentation flipped inside the code

That shift has also inverted a habit I grew up with around documentation. For years the polite advice was to keep comments sparse and let the code speak, which made sense when comments went stale and people treated a wiki as the real source of truth. What I see now is the opposite pressure: AI systems work better, and so do the humans reading after them, when readable context lives next to the behavior it describes.

When that context is embedded in the repo, in comments that explain intent, in skills that encode how we ship, and in task notes that travel with the work, the codebase itself starts to behave like a living manual. A separate page that nobody updates cannot compete with explanation that sits where the agent and the next engineer both look first, and the skills I have been writing for repeatable work are another form of that same idea, since they hold the sequence and the stops in a place the agent can actually use.

I am not arguing for novels in every function so much as for leaving the why where the what already lives, because that is the layer models and people both need when the system is large enough that nobody holds the whole thing alone.

Onboarding as a conversation with the system

For team onboarding, the dynamic changes in a more personal way. New developers used to be forced to hunt through unfamiliar structures, absorb tribal knowledge from whoever had free time, and slowly build a private mental map that took months to feel solid. Now they can engage with agents that act like personalized tutors, explaining architecture and logic on demand, walking a path from a bug report into the modules that matter, and answering the question a wiki would have answered if anyone had kept it current.

That does not replace mentorship so much as change what mentorship is for, because the hour with a senior engineer can start on judgment, tradeoffs, and taste instead of a tour of folders, including how to aim a question so the agent is not guessing in the dark. The same way task context lets someone inherit the picture without another briefing, a well-primed agent lets a new teammate ask the codebase what it already knows and spend human time on what it cannot decide alone, but only once they have enough foundation to recognize a useful question from a vague one.

Mastery is still the steering wheel

Stepping back from typing every line of syntax does not mean giving up technical mastery, and that distinction matters more the faster the tools get. Just because AI can hand you an answer does not mean the work is done, since you still have to know what to ask, or you end up with the blind leading the blind and a confident write-up of the wrong problem. The hallmark of a skilled engineer in this setup is still foundational knowledge: enough systems sense to guide architectural decisions, enough taste to reject a clever abstraction that will hurt next quarter, enough fluency to notice when the generated path is almost right and still wrong, and enough of a mental model to aim the next question instead of hoping the model invents the right one for you.

That expertise is what informs the skills and tools we build, because an agent without a house style and without clear stops will happily produce volume that looks finished. Human oversight remains the guiding force of the system when automation handles more of the implementation, which is why I keep arguing that review, small diffs, and confirmation in a person’s hands are not nostalgia for the old job. They are how the new job stays honest.

I used to spend the first stretch of every investigation just finding the door. Now the door tends to open with context already on the table, and the work that remains is the part I actually want my team practicing: deciding what belongs in the system, teaching the agent how we work, and keeping the manual alive where the code already lives.