Ask HN: How are you LLM-coding in an established code base?

adam_gyroscope · 2025-12-16T18:54:37.000Z

Here’s how we’re working with LLMs at my startup.We have a monorepo with scheduled Python data workflows, two Next.js apps, and a small engineering team. We use GitHub for SCM and CI/CD, deploy to GCP and Vercel, and lean heavily on automation.Local development: Every engineer gets Cursor Pro (plus Bugbot), Gemini Pro, OpenAI Pro, and optionally Claude Pro. We don’t really care which model people use. In practice, LLMs are worth about 1.5 excellent junior/mid-level engineers per engineer, so paying for multiple models is easily worth it.We rely heavily on pre-commit hooks: ty, ruff, TypeScript checks, tests across all languages, formatting, and other guards. Everything is auto-formatted. LLMs make types and tests much easier to write, though complex typing still needs some hand-holding.GitHub + Copilot workflow: We pay for GitHub Enterprise primarily because it allows assigning issues to Copilot, which then opens a PR. Our rule is simple: if you open an issue, you assign it to Copilot. Every issue gets a code attempt attached to it.There’s no stigma around lots of PRs. We frequently delete ones we don’t use.We use Turborepo for the monorepo and are fully uv on the Python side.All coding practices are encoded in .cursor/rules files. For example: “If you are doing database work, only edit Drizzle’s schema.ts and don’t hand-write SQL.” Cursor generally respects this, but other tools struggle to consistently read or follow these rules no matter how many agent.md-style files we add.My personal dev loop: If I’m on the go and see a bug or have an idea, I open a GitHub issue (via Slack, mobile, or web) and assign it to Copilot. Sometimes the issue is detailed; sometimes a single sentence. Copilot opens a PR, and I review it later.If I’m at the keyboard, I start in Cursor as an agent in a Git worktree, using whatever the best model is. I iterate until I’m happy, ask the LLM to write tests, review everything, and push to GitHub. Before a human review, I let Cursor Bugbot, Copilot, and GitHub CodeQL review the code, and ask Copilot to fix anything they flag.Things that are still painful: To really know if code works, I need to run Temporal, two Next.js apps, several Python workers, and a Node worker. Some of this is Dockerized, some isn’t. Then I need a browser to run manual checks.AFAICT, there’s no service that lets me: give a prompt, write the code, spin up all this infra, run Playwright, handle database migrations, and let me manually poke at the system. We approximate this with GitHub Actions, but that doesn’t help with manual verification or DB work.Copilot doesn’t let you choose a model when assigning an issue or during code review. The model it uses is generally bad. You can pick a model in Copilot chat, but not in issues, PRs or reviews.Cursor + worktrees + agents suck. Worktrees clone from the source repo including unstaged files, so if you want a clean agent environment, your main repo has to be clean. At times it feels simpler to just clone the repo into a new directory instead of using worktrees.What’s working well: Because we constantly spin up agents, our monorepo setup scripts are well-tested and reliable. They also translate cleanly into CI/CD.Roughly 25% of “open issue → Copilot PR” results are mergeable as-is. That’s not amazing, but better than zero, and it gets to ~50% with a few comments. This would be higher if Copilot followed our setup instructions more reliably or let us use stronger models.Overall, for roughly $1k/month, we’re getting the equivalent of 1.5 additional junior/mid engineers per engineer. Those “LLM engineers” always write tests, follow standards, produce good commit messages, and work 24/7. There’s friction in reviewing and context-switching across agents, but it’s manageable.What are you doing for vibe coding in a production system?

dazamarquez 152 days ago |

I use AI to write specific types of unit tests, that would be extremely tedious to write by hand, but are easy to verify for correctness. That aside, it's pretty much useless. Context windows are never big enough to encompass anything that isn't a toy project, and/or the costs build up fast, and/or the project is legacy with many obscure concurrently moving parts which the AI isn't able to correctly understand, and/or overall it takes significantly more time to get the AI to generate something passable and double check it than just doing it myself from the get go.

Rarely, I'm able to get the AI to generate function implementations for somewhat complex but self-contained tasks that I then copy-paste into the code base.

missinglugnut 149 days ago | |

My experience is very similar.

For greenfield side projects and self contained tasks LLMs deeply impress me. But my day job is maintaining messy legacy code which breaks because of weird interactions across a large codebase. LLMs are worse than useless for this. It takes a mental model of how different parts of the codebase interact to work successfully and they just don't do that.

People talk about automating code review but the bugs I worry about can't be understood by an LLM. I don't need more comments based on surface level patter recognition, I need someone who deeply understands the threading model of the app to point out the subtle race condition in my code.

Tests, however, are self-contained and lower stakes, so it can certainly save time there.

aspaviento 149 days ago | | |

Legacy code, files with thousands of lines, lack of separation of concern... When I feed that to an LLM it says something like:

function bar() { // Add the rest of your code here }

And barely manages to grasp what's going on.

sourdoughness 152 days ago | |

Interesting. I treat VScode Copilot as a junior-ish pair programmer, and get really good results for function implementations. Walking it through the plan in smaller steps, noting that we’ll build up to the end state in advance ie. “first let’s implement attribute x, then we’ll add filtering for x later”, and explicitly using planning modes and prompts - these all allow me to go much faster, have good understanding of how the code works, and produce much higher quality (tests, documentation, commit messages) work.

I feel like, if a prompt for a function implementation doesn’t produce something reasonable, then it should be broken down further.

I don’t know how others define “vibe-coding”, but this feels like a lower-level approach. On the times I’ve tried automating more, letting the models run longer, I haven’t liked the results. I’m not interested in going more hands-free yet.

qnleigh 150 days ago |

I would be very curious to hear about the state of your codebase a year from now. My impression was that LLMs are not yet robust enough to produce quality, maintainable code when let loose like this. But it sounds like you are already having more success than I would have guessed would be possible with current models.

One practical question: presumably your codebase is much larger than an LLM's context window. How do you handle this? Don't the LLMs need certain files in context in order to handle most PRs? E.g. in order to avoid duplicating code or writing something in a way that's incompatible with how it will be used upstream.

lukevp 149 days ago | |

One thing I think people confuse with context is they see an LLM has say 400k context and think their codebase is way bigger than that, how can it possibly work. Well, do you hold a 10 million line codebase in your head at once? Of course not. You have an intuitive grasp of how the system is built and laid out, and some general names of things, and before you make a change, you might search through the codebase for specific terms to see what shows up. LLMs do the same thing. They grep through the codebase and read in only files with interesting / matching terms and only the part of the file thats relevant, in much the same way you would open a search result and only view the surrounding method or so. The context is barely used in these scenarios. Context is not something that’s static, it’s built dynamically as the conversation progresses via data coming from your system (partially through tool use).

I frequently use LLMs in a VS Code workspace with around 40 repos, consisting of microservices, frontends, nuget and npm packages, IaC, etc. altogether its many millions of lines of code. and I can ask it questions about anything the codebase and it has no issues managing context. I do not even add files manually to context (this is worse actually because it puts the entire file into context even if it’s not all used). I just refer to the files by name and the LLM is smart enough to read them in as appropriate. I have a couple JSON files that are megs of configuration, and I can tell it to summarize / extract examples out of those files and it’ll just sample sections to get an overview.

mattmanser 149 days ago | | |

Yes, I do have a map of the code in my head of any code base I work on. I know where most of the files are of the main code paths and if you describe the symptoms of a bug I can often tell you the method or even the line that's probably causing it if it's a 'hot' path.

Isn't that what we mean by 'learning' a codebase? I know my ability is supercharged compared to most devs, but most colleagues have it to some extent and I've met some devs with an even more impressive ability for it than me so it's not like I'm a magic unicorn. Ironically, I have a terrible memory for a lot of other things, especially 'facts'.

You can sorta make a crappy version of that for AI agents with agent files and skills.

newsoftheday 149 days ago | | |

> You have an intuitive grasp of how the system is built and laid out,

Because they are human, intuition is a human trait, not an LLM code grinder trait.

adam_gyroscope 149 days ago | |

So, it does sometimes duplicate code, especially where we have a packages/ directory of Typescript code, shared between two nextjs and some temporal workers. We 'solve' this with some AGENT.md rules, but it doesn't always work. It's still an open issue.

The quality is general good for what we're doing, but we review the heck out of it.

krackers 149 days ago | |

LLMs currently seem to be very myopic in their planning. Current benchmarks that are being targeted such as SWEbench all reward short-term correctness and completeness, without taking into account long-term refactorability.

In fact, the two are in a sense at odds with each other: refactoring things sometimes means explicitly _disobeying_ the user prompt to "get things done", and going on a side-quest to clean things up. You could manually prompt the LLM to go out and refactor things, but doing that requires _you_ to read the code and identify places that seem suboptimal.

sergeyk 149 days ago |

> AFAICT, there’s no service that lets me: give a prompt, write the code, spin up all this infra, run Playwright, handle database migrations, and let me manually poke at the system. We approximate this with GitHub Actions, but that doesn’t help with manual verification or DB work.

I think this is almost exactly what we've built with https://superconductor.dev

- set up a project with one or more repos

- set up your environment any way you want, including using docker containers

- run any number of Claude Code, Codex, Gemini, Amp, or OpenCode agents on a prompt, or "ticket" (we can add Cursor CLI also)

- each ticket implementation has a fully running "app preview", which you can use just like you use your locally running setup. your running web app is even shown in a pane right next to chat and diff

- chat with the agent inside of a ticket implementation, and when you're happy, submit to github

(agents can even take screenshots)

happy to onboard you if that sounds interesting, just ping me at sergey@superconductor.dev

px1999 149 days ago | |

My org has built internal tooling that approximates this. It's incredibly valuable from a manual test perspective though we haven't managed to get the agent part working well, app startup times (10+ min) make iterating hard.

Do you have customers who have faced/solved this problem? If so, how did they do it -- it seems like a killer on the approach?

sergeyk 149 days ago | | |

Our foundational design value was compute instance startup speed. We've made some design decisions and evaluated several "neocloud" providers with this goal in mind.

Currently, from launching an agent to that agent being able to run tests in our Rails docker-compose environment (and to the live app preview running), is about 30 seconds. If that agent finishes their work and goes to sleep, and then hours later you come back to send a message, it'll wake up in about the same time.

(And, of course, you can launch many agents at once -- they're all going to be ready at roughly the same time.)

adam_gyroscope 149 days ago | |

will email! Your homepage doesn't make the environment part clear - it reads like it's akin to cursor multiple agent mode (Which I think you had first, FWIW).

viraptor 149 days ago |

> To really know if code works, I need to run Temporal, two Next.js apps, several Python workers, and a Node worker. Some of this is Dockerized, some isn’t. Then I need a browser to run manual checks.

There's your problem. It doesn't matter how you produce the code in this environment. Your testing seems the bottleneck and you need to figure out how to decouple that system while preserving the safety of interfaces.

How to do it depends heavily on the environment. Maybe look at design by contracts for some ideas? Things are going to get a lot better if you can start trying things out in a single project without requiring the whole environment and the kitchen sink.

Solving this would improve a lot of things, including LLM success and iteration speed since you could make changes in one place and know which other systems are going to be affected. (Or know that a local change/test is all that's needed)

adam_gyroscope 149 days ago | |

Yeah, we could absolutely do a better job with solid interfaces for each service. To be clear, our nextjs apps, temporal workers, etc are all well defined, and changes in a single package are easily tested (and well tested). It's integration testing we struggle with.

And, there's always a tradeoff here between engineering & our real job as a startup, finding PMF and growth. That said, we want as much eng velocity as possible and a fast, solid integration testing platform/system/etc helps a ton with that.

adzicg 149 days ago |

We use claude code, running it inside a docker container (the project was already set up so that all the dev tools and server setup is in docker, making this easy); the interface between claude code and a developer is effectively the file system. The docker container doesn't have git credentials, so claude code can see git history etc and do local git ops (e.g. git mv) but not actually push anything without a review. Developers review the output and then do git add between steps, or instruct Claude to refactor until happy; then git commit at the end of a longer task.

Claude.md just has 2 lines. the first points to @CONTRIBUTING.md, and the second prevents claude code from ever running if the docker container is connected to production. We already had existing rules for how the project is organized and how to write code and tests in CONTRIBUTING.md, making this relatively easy, but this file then co-evolved with Claude. Every time it did something unexpected, we'd tell it to update contributing rules to prevent something like that from happening again. After a while, this file grew considerably, so we asked Claude to go through it, reduce the size but keep the precision and instructions, and it did a relatively good job. The file has stabilized after a few months, and we rarely touch it any more.

Generally, tasks for AI-assisted work start with a problem statement in a md file (we keep these in a /roadmap folder under the project), and sometimes a general direction for a proposed solution. We ask Claude code to an analysis and propose a plan (using a custom command that restricts plans to be composed of backwards compatible small steps modifying no more than 3-4 files). A human will read the plan and then iterate on it, telling Claude to modify it where necessary, and then start the work. After each step, Claude runs all unit tests for things that have changed, a bunch of guardrails (linting etc) and tests for the wider project area it's working in, fixing stuff if needed. A developer then reviews the output, requests refactoring if needed, does git add, and tells claude to run the next step. This review might also involve deploying the server code to our test environment if needed.

Claude uses the roadmap markdown file as an internal memory of the progress and key conclusions between steps, and to help with restoring the progress after context resets. Pretty much after the initial review, Claude only uses this file, we don't look at it any more. Once done, this plan file is thrown away - tests and code remain. We occasionally ask it to evaluate if there are any important conclusions to record in the architectural design records or contributing guide.

weeksie 150 days ago |

Most of the team uses:

- Claude Code + worktrees (manual via small shell script)

- A root guardrails directory with a README to direct the agent where to look for applicable rule files (we have a monorepo of python etls and elixir applications)

- Graphite for stacked prs <3

- PR Reviews: Sourcery + Graphite's agent + Codex + Claude just sorta crank 'em, sourcery is chatty but it's gotten a lot better lately.

(editor-wise, most of us are nvim users)

Lots of iteration. Feature files (checked into the repo). Graphite stacks are amazing for unblocking the biggest bottleneck in ai assisted development which is validation/reviews. Solving the conflict hell of stacked branches has made things go much, much faster and it's acted as downward pressure on the ever increasing size of PRs.

djeastm 149 days ago |

I don't "vibe code", but I do two main things:

1) I throw it the simpler tasks that I know only involve a few files and there are similar examples it can work from (and I tend to provide the files I'm expecting will be changed as context). Like, "Ok, I just created a new feature, go ahead and setup all test files for me with all the standard boilerplate. Then I review, make adjustments myself (or re-roll if I forgot to specify something important), then commit and move forward.

2) I use the frontier thinking models for planning help. Like when I'm sketching out a feature and I think I know what will need to be changed, but giving, say, an Opus 4.5 agent a chance to take in the changes I want, perform searches, and then write up its own plan has been helpful in making sure I'm not missing things. Then I work from those tasks.

I agree that Copilot's Cloud agents aren't useful (they don't use smart models, presumably because it's $$$) and also I'm not a great multitasker so having background agents on worktrees would confuse the heck out of me.

giancarlostoro 149 days ago |

> AFAICT, there’s no service that lets me: give a prompt, write the code, spin up all this infra, run Playwright, handle database migrations, and let me manually poke at the system. We approximate this with GitHub Actions, but that doesn’t help with manual verification or DB work.

What you want is CI/CD that deploys to rotating stating or dev environments per PR before code is merged.

If deployment fails you do not allow the PR to be approved. Did this for a primarily React project we had before but you can do all your projects, you just need temporary environments that rotate per PR.

giancarlostoro 149 days ago | |

Typo: I wrote "stating or dev" meant to write "staging or dev" whoops

dbuxton 149 days ago | |

I used to love Heroku review apps!

Sevii 152 days ago |

Can you setup automated integration/end-to-end tests and find a way to feed that back into your AI agents before a human looks at it? Either via an MCP server or just a comment on the pull request if the AI has access to PR comments. Not only is your lack of an integration testing pipeline slowing you down, it's also slowing your AI agents down.

"AFAICT, there’s no service that lets me"... Just make that service!

adam_gyroscope 152 days ago | |

We do integration testing in a preview/staging env (and locally), and can do it via docker compose with some GitHub workflow magic (and used to do it that way, but setup really slowed us down).

What I want is a remote dev env that comes up when I create a new agent and is just like local. I can make the service but right now priorities aren’t that (as much as I would enjoy building that service, I personally love making dev tooling).

siliconc0w 149 days ago |

* local development and speed are both important to me so I spend some effort ensuring our app can run fast locally both in a 'lightweight' mode with 'fakes' and in a slower/more accurate prod-like mode.

* We do enable agents to able to interact with the application locally via a browser and some app controls to enable testing certain scenarios but it's generally better to have them iterate by writing and running tests.

* I usually have about three agents going locally via codex/gemini CLIs in separate tabs using work-trees with an IDE to supervise and shepherd them along. Any more and I have trouble feeding them with work and supervising them. I also agree work-trees suck and sometimes I YOLO having agents collaborate on the same tree if I think it'll be less work.

* I use async web agents like codex but really only for paper-cut issues I'm reasonably confident the agent can one-shot or random experiments I'm curious about that I don't really intend to merge.

Right now it's mostly gemini/codex (sorry claude).

throwaway613745 149 days ago |

I use it to write tests (usually integration) that make me physically cringe when I think about how dogged complicated they are to write.

I'll ask it to write one-off scripts for me, like benchmarks.

If I get stuck in some particular complicated part of the code and even web search is not helpful, I will let the AI take a stab at it in small chunks and review every output meticulously. Sometimes I will just "rubber duck" chat with it to get ideas.

Inline code completion suggestions are completely disabled. Tired of all the made up nonsense these things vomit out. I only interact with an AI via either a desktop app, CLI agent, or the integrated agent in my IDE that I can keep hidden most of the time until I actively decide I want to use it.

We have some "foreign resources" that do some stuff. They are basically a Claude subscription with an 8 hour delay. I hate them. Id' replace them with the Github Copilot built-in agent in a heartbeat if I could.

tiku 149 days ago |

I describe functions that I want to change or upgrade. Claude code gives the best results for me. I ask for a plan first to see if it gets what I want to do and I can finetune it then. I have a project that still uses zend framework and it gets it quite good.

nphardon 149 days ago |

This seems wild to me; would lovvvvve to peak at your codebase.

I'm in old school tech in the semiconductor industry. I do a heavy hybrid of pair-coding / vibe coding with my LLM in VsCode, 8 hours a day, across a wide spectrum of tasks. I am always working in C, alternating between implementing a new algorithm, testing, correcting, and analyzing some new technical algorithms either from literature or in house, and then refactoring old bad code written by EE folks 30 years ago (like 100+ line for loops). But I handle all unit tests myself and all code commits myself. I need to get my bot running the unit tests.

I would not be surprised if less than 1/4 my colleagues use an llm agent.

clbrmbr 149 days ago |

Heavy but manual Claude Code usage, always with —dangerously-skip-permissions which makes it an entirety different experience.

I learned a lot from IndyDevDan’s videos on YT. Despite his sensationalism, he does quick reviews of new CC features that you just have to see to understand.

Claude Code has replaced my IDE, though I do a little vim here and there.

My favorite is Claude’s ability to do code archeology: finding exactly when & where who changed what and why.

You do need to be careful of high-level co-hallucination though.

clbrmbr 149 days ago | |

Oh I should add that team adoption is mixed. A lot of folks don’t seem to see the value, or they don’t lean in very hard, or take the time to study the tools capabilities.

We also have now to deal with the issue of really well-written PR messages and clean code that doesn’t do the right thing. It used to be that those things were proxies for quality. Better this way anyhow: code review focuses on if it’s really doing what we need. (Often engineers miss the detail and go down rabbit holes that I call “co-hallucination” as it is not really an AI error, but rather an emergent property.)

mattmanser 149 days ago | | |

To summarize, other people are having to meticulously check the AI slop you're slinging into the system that looks good, but doesn't even do what its supposed to do. And you didn't even check it before submitting the PR?

Must be fun working with you.

KronisLV 149 days ago |

Commented on it a while back here: https://news.ycombinator.com/item?id=46259553

Basically, automated a lot of the checks that previously would be something people do in code review by themselves, now it's all in the change --> build --> fix loop.

Keeps both developers and AIs more disciplined, at least until people silently try to remove some of them.

bitbasher 152 days ago |

I generally vibe code with vim and my playlist in Cmus.

adam_gyroscope 152 days ago | |

Man I was vim for life until cursor and the LLMs. For personal stuff I still do claude + vim because I love vim. I literally met my wife because I had a vim shirt on and she was an emacs user.

weikju 149 days ago | | |

> I literally met my wife because I had a vim shirt on and she was an emacs user.

The editor wars are officially over. Thanks for your story!

WhyOhWhyQ 149 days ago | | |

Claude open in another tab, hitting L to reload the file doesn't do it for you?

hhimanshu 150 days ago |

Have you installed Claude Code Github App and tried assigning the issues using @claude? In my experience it has done better than Github Copilot

rparet 149 days ago | |

(I work for the OP company) We use Cursor's bugbot to achieve the same thing. Agree that it seems better than Copilot for now.

asdev 149 days ago |

how many changes(% of all changes) need an entire infra stack spun up? have you tried just having the changes deployed to dev with a locking mechanism?

PaulDavisThe1st 150 days ago |

We're not. At ardour.org we've banned any and all LLM-generated code (defined as code that was either acknowledged to be LLM-generated or makes us feel that it was).

This is based on continual (though occasional) experiments asking various LLMs for solutions to actual known problems with our code, and utter despair at the deluge of shit that it produces (which you wouldn't recognize as shit unless you knew our existing codebase well). 2 weeks ago, there was the claim that our code makes extensive use of boost::intrusive_ptr<> ... in 300k lines of C++, there isn't a single use of this type, other than in an experimental branch from 6-7 years ago.

So we just say no.

doug_durham 149 days ago | |

Use the tools that work for you. If your customers are happy and you are hitting your deadlines then there is no problem. No one is insisting that you do otherwise.

prayerie 149 days ago | |

This is such a breath of fresh air reading something like this on this website. I thought I was going insane.

jstummbillig 149 days ago | |

How do you review the no?

PaulDavisThe1st 149 days ago | | |

We don't review it, we just say it.

orian 149 days ago |

I use it when I know what and where need to be done, because the complexity of the system and that making mistakes can fail the whole app. I do research in codebase using Claude ultrathink.

Our system is pretty well tested, so this helps a lot.

I know most people at my company use it, and with pretty good results(?)

Personally, I stoped voluntarily reviewing code and caring about quality of code that I’m not responsible for. The AI slop is real and reviewing it is counter-career, instead of pushing product forward and getting praised you spend it fighting with AI. I just accepted that this is how the products looks these days.

koteelok 149 days ago |

I don't

jgb1984 149 days ago |

Based on my experiments with anthropic, openai and gemini, your codebase must be an unsalvageable nightmare by now.

jmkni 149 days ago |

I'm not sure what the answer is, but honestly I think it's good you are asking these questions, we all should be.

All of us are getting these AI tools chucked at us by our managers and being told to do "do AI"...how? Why??

We're in the same boat, we have access to all of the models, all of the tools, the AI budget is there, what the fuck do we do with it?

singularity2001 149 days ago |

bypass permissions on