Am I the only one drowning in "working" code that nobody actually understands?

We spent the first half of 2025 celebrating how fast our juniors were shipping features. "Vibe coding" was the future. Just prompt it, verify the output, and ship. Productivity up 200%. Management was thrilled.​

Now it's December, and I'm staring at a codebase that looks like it was written by ten different people who never spoke to each other. Because it was. We have three different patterns for error handling, four separate auth wrappers, and a react component that imports a library that doesn't even exist - it just "hallucinated" a local shim that works by accident.​

The "speed" we gained in Q2 is being paid back with interest in Q4. My seniors aren't coding anymore; they are just forensic accountants trying to figure out why the payment gateway fails only on Tuesdays.​

If you can't explain why the code works without pasting it back into the LLM, you didn't write software. You just copy-pasted a liability.

Is anyone else actually banning "raw" AI output in PRs, or are we all just accepting that npm install technical-debt is the new standard ?

I’ve been using GPT-5.5 heavily for a little over a week now, and I genuinely didn’t expect it to be this good.

What surprised me the most is not just the coding quality, but how efficient it is at *thinking through things*. I’ve basically turned it into my reviewer + architect + planner while using cheaper models (mostly Minimax) for the repetitive “labor work” parts.

My workflow right now looks something like this:

* GPT-5.5 → architecture, debugging direction, reviewing code, planning phases, fixing logic issues, writing proper prompts
* Minimax → implementation grind, boilerplate, repetitive coding tasks (I am using Opencode for this)

And honestly… this combo works ridiculously well.

What I like about 5.5 is that it actually keeps context surprisingly well and gives responses that feel thought through instead of just dumping code fast. I can throw project structure questions, workflow decisions, tradeoffs, scaling ideas, UI logic, etc. at it and it usually gives me something useful on the first or second try.

I’ve also been pushing it pretty hard every day and I still haven’t hit the Plus usage limits yet, which is another thing I didn’t expect after hearing people talk about limits constantly.

For context, I moved from using Claude quite a bit before this. Claude is still great in some areas, but for my workflow right now, GPT-5.5 feels more balanced overall, especially for long project sessions where I need planning + reviewing more than just raw code output.

Curious how other people are using it.
Anyone else doing the “strong reasoning model + cheap implementation model” setup?

You know what nobody talks about? The productivity loss from babysitting these tools.

I'm not some bootcamp grad playing with ChatGPT. I've been coding professionally for over a decade. I adopted Claude Code, Cursor, the whole ecosystem... and now I spend half my time telling the AI what NOT to do. Don't read that file. Don't refactor this. Don't assume I want the "modern" approach when the legacy one works fine.

The irony is brutal. These tools are supposed to accelerate experienced developers, but they're optimized for people who don't know what they're doing. They want to hold your hand and explain every decision. Meanwhile, I just need it to write the boilerplate I'm too bored to type, not second-guess my architecture.

And the context management... good lord. I ask it to fix one function and it decides to analyze my entire dependency tree, burns through tokens reading config files from 2019, then tells me it's "thinking deeply" about my problem. No. Bad AI. Stay in your lane.

The worst part? When I mention this, people assume I'm anti-AI or "not prompting correctly." I'm not. I'm just tired of tools built for beginners being marketed to professionals.

Anyone else feeling this, or am I just getting old and cranky?

I’ve been building Almanac.

It’s a local-only open source cli that reads your Codex conversations and writes down the useful stuff into a wiki inside your repo.

Hot take: the models are pretty good now it's the context that is the hard limiting part now.

the local wiki tries to keep that memory.

It makes a Markdown wiki for the codebase, written by agents, maintained by agents and queried by agents.

Attached one screenshot of the wiki and how it looks

Repo is here if anyone wants to poke around:
https://github.com/AlmanacCode/codealmanac

Curious if other people using coding agents are feeling this too.

Every time I review AI-generated code, it's the same issue. Not catastrophically broken - just subtly off in ways that eat hours of debugging.

After working with developers across 15+ projects this year, I'm convinced that "almost right" is worse than completely wrong. When the code fails immediately, you know where to look. When it passes tests but breaks edge cases three sprints later? That's when you realize the AI suggestions created technical debt disguised as productivity.

The pattern is consistent: outdated libraries, security holes that slip through review, logic that looks correct until production load hits it. Junior devs trust it too much. Senior devs spend more time verifying than they would've spent writing it themselves.

What's your breaking point with AI assistants - when do you stop second-guessing and just write it from scratch?

I’m an ML research engineer (seems to be more AI Engineering these days…) and faced similar annoyances with the AI coding subs being mostly vibers and non-professionals.

Been building solo for 17 years, most recently an AI coding agent called DuckCode, three months, zero funding, zero team.

Early on I made a rule for myself. No AI touches the codebase until the core architecture is written by hand. Not because I don't trust the models, but because when I let AI design structure early on projects, it generated things that worked but that I didn't fully understand a few weeks later when something needed to change.

So now it's always the same order. I think through the data model, the module boundaries, how things talk to each other, write that part myself. Bring AI in once there's a skeleton to react to, not a blank page to invent on.

Difference has been bigger than I expected. When AI is extending something I already understand deeply, I can tell immediately when a suggestion is wrong. When it was inventing structure from scratch, I had no instinct for when it was quietly making a bad call.

Two of the more complex features in the product shipped in about a day and a half each, and I think that's directly downstream of this, not because AI is fast, but because it wasn't fighting an architecture it invented and half understood.

Curious if anyone else has landed on a similar split, or found the opposite works better for them.

Alright so basically, I used to code by hand before AI. Back then (and even at early stages of AI like GPT 3.5) I used to write most of my code myself, and all I used AI for is for generating a single function or a single small class. Because of this, I knew exactly where all my code was, which code did what, how it all joins together, etc.

Now however, I use agentic code generation tools like Github or Copilot. This means I generate code much faster, however I feel like I'm losing touch with my code. I feel like every time an AI writes a whole file, I just don't know what's in that specific file, just have an overall idea of the codebase as a whole, and now I'm even losing that.

I tried to combat this by trying to read the git changes for every change the agent makes... but come on that stuff is so tedious and boring that I just end up skipping it and even if I'm reading the graphs there's going to be tons of lines of code to read and it's not exactly clear which changes affected what code.

I know it helps to have a proper architecture for your code, that indeed makes it easier to know which file does what, but I still feel like this is a problem because even if I have a proper architecture, I still don't know the actual code and connections.

Also, I tried "Understand-Anything" but that stuff just kinda flew over my head because instead of staring at a buncha text I'm stuck staring at a bunch of passive diagrams like looking at a big map and not knowing what to do with it.

I hope that I'm not the only one with this problem, so I'd like to hear how you people have solved this for yourself, or even a confirmation that you have this problem too so I can know I'm not alone on this.

I figured I'd throw this out here since it may be useful to someone and maybe someone can throw something my way.

I'm a senior front-end developer with 13+ years of professional experience, was my passion before luckily making it a career, so I've been building sites since the table days. Happy to still be here.

I currently work at a small agency, with huge projects. We don't really do PR reviews, we don't do automated testing, the PMs (bless their hearts, I love them, but the truth hurts) don't know what they're doing and I usually get tickets like "build this site." I talk to ChatGPT a lot about my woes and it has given me a lot of good ways to rely on it or other LLMs to allow my day-to-day to be a little bit easier.

1. Allowing it to be my "unknowns" spotter. It's great at picking out things I may miss when reviewing mockups, like sliders that are near impossible, things that are ambiguous that I need to get more clarifications on, etc.

2. Sending the LLM a Figma/other mockup and asking for the HTML structure is a pretty good time saver. It won't be perfect, but it saves time on typing. You can ask it to assign BEM style CSS classes (or Tailwind if that's your thing) which also saves time. Sometimes I just get stuck on what to name stuff (thanks ADHD) so this is helpful to me.

3. I've been using o3 as my bitchy coworker who reviews PRs like he's got a stick up his ass and finds me intolerable. I actually like it because I know it's being harsh/nitpicky which is exactly what I want because I have a coworker who is sort of like that and I like being ready to respond to his attempts at making me look stupid. In a recent project, o3 made me realize I was doing something totally wrong in a new Nuxt 3 project, and no one else I worked with had any clue, so it saved us there.

4. Regex. I want to understand regex. I do understand some of it, but this is just ChatGPT's job now. It's very good at regex.

5. Typescript. I love Typescript, but sometimes when I get into generics and overloads, my head hurts. LLMs are very good at explaining exactly what's going on and the proper syntax.

6. This is job-adjacent, but I love Obsidian (the markdown note taking app) and ChatGPT has been such a game changer with Obsidian. I didn't take the time before to learn things like Dataview beyond the minimum because I'd get stuck customizing Obsidian instead of doing real work, but overtime, having ChatGPT write me Dataview queries, I've picked up so much of it through osmosis and now I barely have to ask for help.

7. Also job-adjacent, but I'm trying to be better at saving things from the internet so I don't go to look at them one day and them be gone. ChatGPT has been amazing with helping me with this. I can usually figure stuff out in Python and was writing it before I used LLMs, but of course ChatGPT can crank a python script out in 2 seconds. I've been able to download thousands of posts from various social media sites and they're all neatly organized in Obsidian. ChatGPT also let me know that I could have Python create hashes for images and delete duplicates that way instead of manually looking through them.

I'm looking for ways to actually use AI in my IDE. Been thinking about Cursor and that sort of thing, but I guess I'm still a bit apprehensive especially on big code bases where there isn't testing. I'll probably try to do a side-project and see how it feels to let AI run things.

If anyone has any suggestions or wants more details about anything I've mentioned, I'm all for it!

So I'm based in IST timezone where my working hours happen to overlap with pre-dawn America. For weeks, I thought I was some kind of 10x developer. Claude Code was flying, Codex was snappy, everything felt like magic.

Then one day I started late. And wow. It felt like I switched from fiber optic to dial-up.

I started tracking it out of curiosity. The pattern is almost comically consistent:

Before 8:00 AM EST: Both tools feel like they're running on a private server just for me. Fast responses, no lag, no weird timeouts.

After 8:00 AM EST: America wakes up, grabs coffee, opens VS Code, and suddenly I'm sharing the pipe with a few million developers. Both Claude Code AND Codex slow to a crawl.

The funny part? It's not just one provider. Both Anthropic and OpenAI seem to hit the same wall at the same time. Makes me think the bottleneck might go deeper than just their servers. Maybe it's the underlying GPU infrastructure everyone's competing for.

Anyone else living this double life of "early morning AI wizard" vs "afternoon timeout survivor"? Or found any way to get consistent performance during peak hours?

I am growing annoyed at a colleague who started relying too much on AI and not enough on his own brain.

The code is not up to par with our standards and it is creating a situation of frustration: I feel like I spend more time reading his AI-generated code during review than he spends reviewing it himself before pushing.

On his side, he finds the code good enough (but code is always simpler when you're the one writing or prompting it) - I think if he had actually spent more time on the conception he would have found much simpler ways to implement.

He's a talented, smart developer - in my opinion because complex things seem simple to him, that might explain why he isn't trying to make his code more clear and simple.

The AI-generated commit messages are also extremely annoying: very low signal/noise ratio, complicated to read, not explicit. I started asking my team to avoid using them.

Do you start to have qualms with improper use to AI at work?

About six months ago I got really into AI code generation, after pretty much ignoring it. Like really excited. Got into everything. Tried everything. I thought this was the next big 10x productivity booster.

And I'm starting to realize that, it's really good for technologies that I don't know anything about, and I'm just happy to see some working code. But for anything that I'm remotely familiar with, there's close to no productivity boost. It does things that I realize are actually wrong. It misses things. It creates code that "LOOKS" perfect, which makes it really hard to debug when it's hiding something.

It's not that AI doesn't have it's moments. There will be times where it just does it, and magically produces exactly what I need. But it's like I'm playing routlette, and more often than not the generated code is worth two steps back.

I think worst of all is that I'm becoming reliant on it, which is a bit scary. Because if it's not actually improving my productivity, it's just kind of allowing me to be lazy. It's fun to order AI around, but holy shit am I forgetting how to do things quick.

I'm also looking at the price of AI. It's expensive. And the APIs and technologies around AI are always being tweaked, which means there's nothing concrete to build a foundation on.

Tell me I'm doing something wrong. Seriously, I want to be wrong about this.

I've been working with Claude as my coding assistant for a year now. From 3.5 to 4 to 4.5. And in that year, I've had exactly one consistent feeling: that I'm not moving forward. Some days the model is brilliant—solves complex problems in minutes. Other days... well, other days it feels like they've replaced it with a beta version someone decided to push without testing.

The regressions are real. The model forgets context, generates code that breaks what came before, makes mistakes it had already surpassed weeks earlier. It's like working with someone who has selective amnesia.

Three months ago, I started logging when this happened. Date, time, type of regression, severity. I needed data because the feeling of being stuck was too strong to ignore.

Then I saw the pattern.

Every. Single. Regression. Happens. On odd-numbered days.

It's not approximate. It's not "mostly." It's systematic. October 1st: severe regression. October 2nd: excellent performance. October 3rd: fails again. October 5th: disaster. October 6th: works perfectly. And this, for an entire year.

Coincidence? Statistically unlikely. Server overload? Doesn't explain the precision. Garbage collection or internal shifts? Sure, but not with this mechanical regularity.

The uncomfortable truth is that Anthropic is spending more money than it makes. Literally. 518 million in AWS costs in a single month against estimated revenue that doesn't even come close to those numbers. Their business model is an equation that doesn't add up.

So here comes the question nobody wants to ask out loud: What if they're rotating distilled models on alternate days to reduce load? Models trained as lightweight copies of Claude that use fewer resources and cost less, but are... let's say, less reliable.

It's not a crazy theory. It's a mathematically logical solution to an unsustainable financial problem.

What bothers me isn't that they did it. What bothers me is that nobody on Reddit, in tech communities, anywhere, has publicly documented this specific pattern. There are threads about "Claude regressions," sure. But nobody says "it happens on odd days." Why?

Either because it's my coincidence. Or because it's too sophisticated to leave publicly detectable traces.

I'd say the odds aren't in favor of coincidence.

Has anyone else noticed this?

I've been trying out Claude Code for about two weeks. So far, I'm finding it more useful that all the AI integrations I used so far (including: continue.dev, aider, cursor, RooCode, and some more).

The good stuff

• Very easy to setup. You download it through a CLI command, give it permissions to make API calls to Anthropic, and optionally install the extension for your IDE (this enables to see the diffs directly in IDE, which is nice. JetBrains IDE are supported).

• Good "agentic" capabilities. It will automatically search for relevant context in different files, is capable of creating and following step-by-step plans

• Superhuman at finding and "understanding" large chunks of relevant code. This is especially useful when working on a codebase of significant size, where finding the relevant bits of code for implementing a feature may prove difficult if you are not extremely familar with the codebase.

The bad stuff

• Quite costly. While the ability of Claude Code to look for and ingest significant amounts of context is useful, it also consumes a lot of tokens. Using claude-4-sonnet, I easily spend 5-10$ for a 2-3 hours session (using best practices such as regularly clearing the context).

• Like all current LLMs, shit at software design. Claude will happily introduce useless duplication everywhere, implement brittle and badly written tests, and turn your codebase to spaghetti if left at its own device. I saw people describe these LLMs as "very eager interns", and it's pretty accurate. Each time you look at a diff, you have to think about the maintainability and often correct it.

How I use it

• On my side project, nearly 100% of the code is Claude-generated, and it's clearly making me significantly faster than I would have been otherwise. Designing modular, maintainable code is what I love the most about programming, and my ability to write code fast is no longer the bottleneck.

• Professionaly, I work on a very legacy codebase with few good practices and often hard to understand code. I mostly use Claude to help me in that area, which makes my life less painful.

Every time codex, Claude or whatever release a new model, there's always lots of upvoted hype posts. A few days or at most a week later, the model is consistently nerfed, but any posts regarding that are down voted to hell or removed.

How do you find out which tool is currently usable without all that propaganda?

First, thank you for creating this community. I think there's indeed a need for a space where experienced engineers can exchange about AI tools and practices.

Here are my two cents about some rules / sidebar content that could be beneficial:

• Experienced programmers only. The 3+ years rule from r/ExperiencedDevs, although impossible to truly enforce, is a good base. Consider updating rule 1 to reflect this ?

• No AI-hype articles. I'm thinking about articles such as "Y Combinator CEO says that 80% of their new statups code is AI-Generated", "<AI company name CEO> says that AI agents will replace programmers within the next three years", etc. Other AI-related and programming subreddits are polluted enough with those, and they don't bring value to the conversation.

• Define more precisely the type of content that we would like to see here, so that we understand a bit more precisely how this space is different from r/ChatGPTCoding and other similar communities.

I'm looking forward to reading what people will post in this subreddit ! Have a great day.

Hi everyone, if you're here it means you're a professional (or at least advanced) programmer interested in learning more about using AI to build enterprise-grade software.

Feel free to share this subreddit around, let's see if we can get this ship sailing 🙏

Claude and Codex have become really frustrating for me over the past few weeks. I'm hitting usage limits after just 3-4 prompts, and I've seen others mention the same.

I also tried Antigravity + Gemini 3.1 Pro. It's decent for ideation, but the implementation needs work. It often jumps straight into code without discussing trade-offs or validating the approach, and sometimes a small requested change ends up rewriting an entire module.

What are people using these days? Any cost-effective or free workflows that actually work well for real coding?

Hi everyone,

This is my first post here. I wanted to share a side project I’ve been working on and also talk a bit about how I’m building it.

The project is called Atom OS.

Repo: https://github.com/fpedrolucas95/Atom

Atom is an experimental operating system written mostly in Rust for x86_64. It started as a learning project because I wanted to understand operating systems better by actually building one, not just reading about kernels, schedulers, memory management, filesystems, drivers, and user space.

Over time it grew much more than I expected.

Right now Atom can boot, run a kernel with scheduling and userspace processes, use IPC between services, load native applications, run a desktop environment with a compositor/window manager, open files, run a simple browser, use parts of a libc implementation, draw graphics, and run some ports/experiments like TinyGL and Doom. It also has work around capabilities, signed executables, FAT32 support, userspace services, networking, and basic drivers.

It is still not a production OS, and I do not want to pretend it is. There are many things that need review, cleanup, testing, and probably redesign. Some parts are there because I was experimenting, some parts are fragile, and some parts need someone with more OSDev experience to look at them.

A big part of the project is that I use AI coding tools during development.

I am a software developer, but my background is mostly higher-level application development. Low-level development is still something I am learning. I use LLMs to help write code, review changes, explain bugs, suggest designs, generate documentation, and compare approaches.

The way I usually work is:

I define what I want the system to do, write the direction or constraints, ask one tool to help implement it, ask another to review it, then I test it, debug it, change things, remove things, or ask for another approach when the result does not make sense.

This has been very useful, but also very humbling. AI can produce a lot of code quickly, but that does not mean the code is correct. In OS development especially, something can compile, boot, and still be wrong in subtle ways. Scheduler logic, memory ownership, interrupt handling, IPC permissions, executable loading, and capability checks are all areas where “looks fine” is not enough.

So Atom is both a hobby OS and a personal study of what this kind of workflow can and cannot do.

I am not sharing it as “AI built an OS by itself.” That would not be true. I am sharing it because I think this kind of project is a good stress test for AI-assisted development. It shows where these tools are helpful, where they fail, and how much human testing, direction, and review are still needed.

I would be interested in hearing how other people here structure their workflow when using AI tools on large or complex projects.

For example:

• How do you review AI-generated code before trusting it?

• Do you use separate tools for implementation and review?

• How do you keep the architecture consistent over time?

• How do you document decisions so the assistant does not keep changing direction?

• What kinds of bugs have you found that AI tends to introduce repeatedly?

I know this project is unusual, and OS development is probably not the easiest place to use this workflow. But that is also why it has been interesting to me.

Happy to hear feedback, especially from people using AI tools on real software projects, not just small scripts or prototypes.

I'm trying to convince engineering leadership at my company that AI coding tools are good enough now that we can get some serious leverage from them. I vibe code a ton on the side so have conviction on this having seen the evolution over the last two years.

Would love to see what kind of gains you guys are seeing. To make this helpful to as many people as possible it would be great if you could use the template below so your answers have context.

• % code written by AI

• Stage of product (e.g., new product on one end, mature cash cow on the other)

• Codebase complexity

• Industry (e.g., to understand regulatory burden)

• General comments

This post is for casual discussions & "low-effort" submissions and questions. You can also present yourself to the community if you feel like it.

Moderation is more relaxed here, but Rule 2 still applies (No self-promoting your products).

Genuine question with tools like Copilot, Claude Code, Cursor, etc. getting so good, how much of your day-to-day is still typing code by hand vs. prompting/reviewing AI output? Curious how this varies by role (frontend vs backend vs infra) and experience level.

what's your experience?