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

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.

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.

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

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)

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.

- 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.

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.

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.

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

* 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).

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.

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.

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.

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.

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.

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.

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?

I think at a fundamental level, I expect we can produce higher quality software under budget. And I really liked how you were clearly thinking about cost benefits especially in your setup. I’ve encountered far too many developers that just want to avoid as much cognitive work as possible. Too many junior and mid devs also are more interested in doing as they are told instead of thinking about the problem for themselves. For the most part, in my part of the world at least, junior and mid-level devs can indeed be replaced by a claude code max subscription of around $200 per month and you’d probably get more done in a week than four such devs that basically end up using an llm to do work that they might not even thoroughly explore.

So in my mind I’ve been thinking a lot about all aspects of the Software Development LifeCycle that could be improved using some llm or sorts.

## Requirements. How can we use llms to not only organize requirements but to strip them down into executable units of work that are sequenced in a way that makes sense. How do we go further to integrate an llm into our software development processes - be it a sprint or whatever. In a lot of green field projects, after designing the core components of the system, we now need to create tasks, group them, sequence them and work out how we go about assigning them and reviewing and updating various boards or issue trackers or whatever. There is a lot of gruntwork involved in this. I’ve seen people use mcps to automatically create tasks in some of these issue trackers based on some pdf of the requirements together with a design document.

## Code Review - I effectively spend 40% of my time reviewing code written by other developers and I mostly fix the issues I consider “minor” - which is about 60% of the time. I could really spend less time reviewing code with the help of an llm code reviewer that simply does a “first pass” to at least give me an idea of where to spend more of my time - like on things that are more nuanced.

## Software Design - This is tricky. Chatbots will probably lie to you if you are not a domain expert. You mostly use them to diagnose your designs and point out potential problems with your design that someone else would’ve seen if they were also domain experts in whatever you were building. We can explore a lot of alternate approaches generated by llms and improve them.

## Bugfixes - This is probably a big win for llms’ because there used to be a platform where I used to be able to get $50s and $30s to fix github bugs - that have now almost entirely been outsourced to llms. For me to have lost revenue in that space was the biggest sign of the usefulness of llms I got in practice. After a typical greenfield project has been worked on for about two months, bugs start creeping in. For apps that were properly architected, I expect these bugs to be fixable by existing patterns throughout the codebase. Be it removing a custom implementation to use a shared utility or other or simply using the design systems colors instead of a custom hardcoded one. In fact for most bugs - llms can probably get you about 50% of the way most of the time.

## Writing actual (PLUMBING) code . This is often not as much of a bottleneck as most would like to think but it helps when developers don’t have to do a lot of the grunt-work involved in creating source files, following conventions in a codebase, creating boilerplates and moving things around. This is an incredible use of llms that is hardly mentioned because it is not that “hot”.

## Testing - In most of the projects we worked on at a consulting firm, writing tests - whether ui or api was never part of the agreement because of the economics of most of our gigs. And the clients never really cared because all they wanted was working software. For a developing firm however, testing can be immense especially when using llms. It can provide guardrails to check when a model is doing something it wasn’t asked to do. And can also be used to create and enforce system boundaries especially in pseudo type systems like Typescript where JavaScript’s escape hatches may be used as a loophole.

## DEVOPS. I remember there was a time we used to manually invalidate cloudfront distributions after deploying our ui build to some e3 bucket. We’ve subsequently added a pipeline stage to invalidate the distribution. But I expect there are lots of grunt devops work that could really be delegated. Of course, this is a very scary use of llms but I daresay - we can find ways to use it safely

## OBSERVABILITY - a lot of observability platforms already have this feature where llms are able to review error logs that are ingested, diagnose the issue, create an issue on github or Jira (or wherever), create a draft PR, review, test it in some container, iterate on a solution X times, notify someone to review and so on and so forth. Some llms on this observability platform also attach a level of priority and dispatch messages to relevant developers or teams. LLms in this loop simply supercharge the whole observability/instrumentation of production applications

But yeah, that is just my two cents. I don’t have any answers yet I just ponder on this every now and then at a keyboard.

1. Context-aware prompting: We maintain a .ai-context folder with architecture docs, coding standards, and common patterns. Before asking the LLM anything, we feed it relevant context from these docs.

2. Incremental changes: Rather than asking for large refactors, we break tasks into small, testable chunks. This makes code review much easier and reduces the "black box" problem.

3. Test-first development: We ask the LLM to write tests before implementation. This helps ensure it understands requirements correctly and gives us confidence in the generated code.

4. Custom linting rules: We've encoded our team's conventions into ESLint/Pylint rules. LLMs respect these better than prose guidelines.

5. Review templates: We have standardized PR templates that specifically call out "AI-generated code" sections for closer human review.

The key insight: LLMs work best as pair programmers, not autonomous developers. They're excellent at boilerplate, test generation, and refactoring suggestions, but need human oversight for architectural decisions.

One surprising benefit: junior devs learn faster by reviewing LLM-generated code with seniors, compared to just reading documentation.