One thing that feels different with AI-generated code is that the "design discussion" often happened inside the prompt instead of the PR.
In traditional workflows, a lot of the reasoning is visible through commit history, comments, or intermediate refactors. With LLMs, the reasoning step can be hidden because the model collapses that exploration into a single output.
What we've started doing internally is asking for two artifacts instead of just the code:
1. the prompt or task description that produced the code
2. the generated code itself
Reviewing both together gives you much better context about the intent, constraints, and tradeoffs that led to the implementation.
One day I started getting API errors across requests and initially assumed it was something on my side. After digging into it, the provider I was using was getting overloaded and intermittently failing.
That was the moment I realized relying on a single external service was a risk I hadn’t really planned for.
Now I keep two providers configured: a primary and a secondary. If error rates spike or the API stops responding, the system can fail over instead of the whole product going down.
It added a bit of complexity, but the peace of mind is worth it.
Memes are basically compressed cultural references. If a model sees the same meme structure repeated across a lot of contexts, it could learn that a short phrase carries a lot of shared meaning for humans.
The interesting question is whether models will start inventing new shorthand metaphors the way engineering culture does ("yak shaving", "bikeshedding", etc.), or whether they'll mostly reuse ones already embedded in the training data.
One thing that might also be happening is that LLMs tend to converge on metaphors that compress complex ideas quickly.
If you look at how engineers explain messy systems, they often reach for anthropomorphic metaphors — “gremlins in the machine”, “ghost in the system”, “yak shaving”, etc. They’re basically shorthand for “there’s hidden complexity here that behaves unpredictably”.
For a model generating explanations, those metaphors are useful because they bundle a lot of meaning into one word. So even if the actual frequency in normal conversation is low, the model might still favor them because they’re efficient explanation tokens.
In other words it might not just be training frequency — it could be the model learning that those metaphors are a compact way to communicate messy-system behavior.
AI coding tools feel like they’re shifting the bottleneck in building.For a long time the hardest part was implementation — frameworks, infrastructure, deployment, etc.Now it feels like the harder problem is understanding systems and user behavior well enough to build something useful in the first place.
In a weird way it’s making software development feel more like engineering again rather than constant framework churn.
In traditional workflows, a lot of the reasoning is visible through commit history, comments, or intermediate refactors. With LLMs, the reasoning step can be hidden because the model collapses that exploration into a single output.
What we've started doing internally is asking for two artifacts instead of just the code:
1. the prompt or task description that produced the code 2. the generated code itself
Reviewing both together gives you much better context about the intent, constraints, and tradeoffs that led to the implementation.