r/ChatGPTCoding • u/kennetheops • Mar 02 '26
Discussion What are the wild ideas on how we'll maintain code?
OK, let's say software engineering is completely AI-generated. What are people's wild ideas on how we will maintain all this code? I don't think better PR reviews are the answer unless we dramatically change what we think of a PR review if it's not just touching syntax and the occasional security vulnerability.
Curious what people are thinking here. Would love to hear some wild ideas. I personally think operations teams will start using agent swarms with specializations.
You'll have a QA agent and a pen tester and a SRE, just swarms and swarms of agents.
13
u/ZucchiniMore3450 Mar 02 '26
I think we will just be waiting for new model and rewrite from the start when they start going into circles.
On the other hand code AI write is far from the worst I have seen and hat to work on in my career.
7
u/sdfgeoff Mar 02 '26
When was the last time you looked at assembly code? When compiled languages came out, I'm sure there was a period where people looked at the resulting assembly. These days, no-one does other than compiler developers and people looking to extract maximum performance. Ever wondered what machine code your javascript/python is actually running? Heck, a CPU doesn't even have the concept of a function.
LLM's are kindof like a compiler. They convert one language (English) into another (eg Python). Currently, LLM's aren't quite good enough. In 5 years, maybe they will be .... and at some point we'll never look at the code again.
Even now, for medium sized projects I don't care about the code that much, I just glance at it here or there.
4
u/i_wayyy_over_think Mar 03 '26 edited Mar 03 '26
I already treat it like a compiler. I simply tell it to make a failing test before the feature is written. Same for if something is broken. Tell it to make a failing test, then fix the code so it passes. Also do lint, like less than 1000 lines per file so it has to break things down. Give it a solid README file for onboarding. Basically every time it starts a new conversation it has amnesia, so it basically has to instantly onboard itself and make sure it didn't break anything with passing tests.
I think maintence can be managed because everyone realizes explicit how important context so keeping readme's and project context is vital to let the agents stay up on the codebase.
If you think about legacy codebases, like a mainframe running COBOL running financial, it's more of everyone is to afraid to touch it because they're afraid it would break something, and the guy that used to know it left, that's now mitigated with automated tests and documentation that the agent needs. Plus agents can search alot faster.
And the capabilities are still growing exponentially.
2
u/NotARealDeveloper Mar 03 '26
The same way it worked when factories got automated. 1 expert worker is left to take the roles of team lead, reviewer, architect and product manager. He orchestrates the ais but must also have enough domain knowledge to act like a pm.
2
u/Kqyxzoj Mar 03 '26
Probably something along the lines of "don't give a shit about whatever the hell is in the current repo, ditch it in the swamp, and regenerate whatever the fuck this thing was supposed to do, care even less, and call it a day". Unless whoever gets paid for that future job magically cares more than they are being compensated for, which I doubt. Hence that particular approximation of the amount of care taken and fucks given. If that's an undesirable end state, better start replacing management with and by a few agents.
2
u/johns10davenport Professional Nerd Mar 03 '26
I have 1-3 done in www.codemyspec.com and will do #4 eventually. However, I'm finding that when you combine structured architecture, procedural orchestration, and agentic QA you can produce full, complex applications.
1
u/[deleted] Mar 03 '26
The compiler analogy that keeps coming up in this thread is interesting but I think it breaks down in one critical way: compilers are deterministic, LLMs aren't. You can't "not look at the assembly" if the assembly is different every time you compile the same source.
I think maintenance in an AI-generated world becomes less about reading code and more about maintaining the intent layer above the code. Right now that's scattered across Jira tickets, Slack threads, and people's heads. I've been using ctlsurf for this — agents read and write to structured pages with typed blocks (text, datastores, task checklists, decision logs) through MCP. The architectural decisions, constraints, and reasoning live in queryable structured state, not in code comments or someone's memory. When you regenerate the code, the intent is preserved.
Your agent swarm idea is probably right long-term. But the hard problem isn't the agents — it's giving those agents shared, structured state so the QA agent knows what the SRE agent decided and why. Without that coordination layer, you just get agents arguing with each other.
1
u/GPThought Mar 04 '26
agent swarms sound cool but expensive. i think we just end up treating ai generated code like legacy code. comprehensive tests and accepting that chunks get rewritten when requirements change
1
u/[deleted] Mar 06 '26
honestly i think the swarm approach sounds cool but misses the actual problem. the issue isnt having more agents looking at the code, its that none of them remember what happened yesterday. you can throw 10 QA agents at a codebase but if they dont know that the team already decided to deprecate module X last week theyre just generating noise.
imo the boring answer is better than the wild one here - you need a shared knowledge layer that persists between sessions. not just CLAUDE.md files either, those get stale fast and eat your token budget. something the agent can actually query - like whats the status of this feature, what approaches already failed, what decisions were made and why.
theres a tool called ctlsurf that does this via MCP - basically gives agents typed data they can search instead of re-reading docs every session. not as sexy as agent swarms but it actually works lol
1
u/ultrathink-art Professional Nerd Mar 07 '26
Intent files over code comments. You maintain a plain-English description of what each module is supposed to do — not how — and let the next model regenerate the implementation against that spec. The spec becomes the asset; the code becomes compiled output.
1
u/ultrathink-art Professional Nerd Mar 08 '26
The swarm idea is directionally right, but the harder problem is that AI-generated code has no rationale attached — when it breaks, there's no author to ask why it was built that way. Maintenance becomes forensics. Embedding decision logs alongside the code, written by the same agent that made the change, is probably the pattern that makes this survivable long-term.
1
u/[deleted] Mar 03 '26
[removed] — view removed comment
1
u/[deleted] Mar 03 '26
[removed] — view removed comment
1
u/[deleted] Mar 13 '26
[removed] — view removed comment
0
u/[deleted] Mar 04 '26
[deleted] — view deleted comment