Rendered at 04:10:08 GMT+0000 (Coordinated Universal Time) with Cloudflare Workers.
sadilek 7 hours ago [-]
I have not done a systematic ablation study, so not all things might be necessary, but anyway, here's what's working for me very well (in no particular order):
0. Use Opus 5.5 on high.
1. Have in your CLAUDE.md the rule that code changes go together with updates to the docs. For me, that's HTML files in docs/. (Could be .md as well, but for human consumption, HTML is nicer.)
2. Have the rule that only that should go into the docs that an experienced engineer would need to rebuild the system from scratch, ignoring how it would look.
3. Larger work gets a plan doc in docs/plan, i.e. multi-PR work. There is a template how plans look, and an important part of the template is that the last step of the plan is always to delete the plan and fold anything from it that makes sense as long-term documentation into the docs.
4. Have a rule that before creating a PR, a sub agent needs to review the code, and have Codex Sol 6.1 high review it as well. Then let the main agent iterate on their findings until they are happy.
5. Every now and then, ask for an audit of the code. I ask for DRY, YAGNI, and KISS. Let it produce a report. Then let it fix all findings. If a lot, use a plan.
6. If you're adding something straight forward, just ask for it directly. If it's not, ask for a brief first. Review it. Then decide whether to implement in one go or through a plan.
7. Get an ultra plan, so you (mostly) don't have to worry about token usage but can use agents to their full ability.
8. Bonus and plug: Ask your agent to hand over with a demo video. It often finds and fixes issues while recording it, and you're not degraded to the agent's QA team, but it has to put in the work to convince you. I built a UI for directing agents as described: obeya.si. Free, open-source, local.
gabe84700 18 minutes ago [-]
1. Design first. Vibe design before vibe code
2. Build all CRUD operations for all data entities and clean your database regularly
EduardoBautista 52 minutes ago [-]
I have Claude run the simplify and code-review skills as part of verification. Also every month or so I use the tech-debt skill on all my codebases and fix any issues. The more tech debt you have, the more the models start doing strange things.
And the usual stuff any decent CI pipeline should have: tests, builds, linting, SQL breaking changes and potential heavy migration checks, etc.
smallerize 9 hours ago [-]
One thing that's surprisingly powerful is to just say what you want in the prompt. One of my skill files now includes "inspect existing code under [subdir] for implementation patterns." Depending how much code you have, that might take a lot of tokens. You could either list the patterns that you want or include a smaller code sample in the skill's references.
A stronger version of this would be to make a separate gate. Fail the commit if the new code duplicates something already in a utility function, renames something that already had a name, uses for-loops instead of list comprehensions, whatever is bothering you.
mpd 9 hours ago [-]
I've always been a bottom-up programmer, so I tend to think more about discrete operations of software rather than the user-facing features (which IME will fall out naturally).
1. Experiment and solidify architecture before adding features. I think this is the hardest step for top-down thinkers.
2. Heavy testing and benchmarking. Prefer to TDD as much as possible. The actual lines for my agent-written codebases are generally ~70+% tests, benchmarks, and experiments.
3. Full mutation test coverage after the code is written. Doing this as a human is miserable IMO, but robots make it reasonable. This step resolves SO MANY subtle bugs.
At that point my main role is ensuring alignment with the actual specs.
nkcodes 9 hours ago [-]
Yeah I feel like what you say makes sense. Part of my issue comes from the fact that we're a pre-PMF startup, so rapid experimentation and prototyping really matters at the moment with very little room left for deep thought around testing and benchmarking.
The trouble comes later when the "experimental features" actually start getting traction and we discover all the holes in our implementation.
By the time we need to "productionize" our experiment, it has already been patched all over the place to account for bugs.
I get a feeling that this is made worse by the fact that since a lot of what we're doing is rapid prototyping, our repo is cluttered with examples of bad code that the agent picks up on and then goes ahead to copy in its own implementation.
I get that we need to clean this up, but it's crazy trying to figure out where to start and what to tackle
mpd 9 hours ago [-]
One of my mantras is 'fast is the best UX'. Users will put up with minor annoyances as long as they're over with quickly. Once you fix the annoyances, you're still fast, which leads to User Delight.
> I get that we need to clean this up, but it's crazy trying to figure out where to start and what to tackle
Enumerate, then fix-or-nix all known examples of bad code first. If you clear the path first, you will advance more quickly. It can feel frustrating having to do that, but my experience is that paying off tech debt earlier will prevent hitting the wall at an inopportune time.
sjducb 8 hours ago [-]
If you’re pre PMF then don’t worry about code quality. (Seriously)
Pump out features and iterations as fast as you can until customers are buying your product.
Startups fail because they can’t find customers, not because their code quality is low.
rafabitt 2 hours ago [-]
Coming from someone with a non technical background that has started building things post AI, I think what helps me the most is referencing other successful products and learning from their bad reviews/mistakes.
Now to your question specifically, I believe it's not that hard to maintain quality when you're not obsessing over a million features, what I've seen people do is make their app or software do everything instead of focusing on a sum of functionalities that are actually worth keeping and will certainly impact the user experience.
alexjplant 7 hours ago [-]
OpenSpec solves this incidentally by dividing work into planning, implementation, and archiving phases. If you tell it what you're doing and the business reasons during planning (and bicker with it about technical implementation) then it goes off the rails much less when it actually does the work. You can also PR the spec to coworkers before implementation and run the implementation step in a new context to keep it more on track.
llbknapik 5 hours ago [-]
I personally build rules using static analysis tools. All my guardrails hook into my .NET static analyzer pipeline. This makes the agent fail at build time then it goes and corrects itself.
Additionally, .NET added a bunch of formatting rules in its static analyzer for .NET 11 that give greater control on the styling of the code the agent generates. For example you can ban `=>` function syntax using editorconfig. The build will fail and the agent has to adjust.
purple-leafy 7 hours ago [-]
Have a vision, and know what to say no to [0]. Thats how I build all my own projects, most recent here for example
I'm not sure if there is any standard for this, I also tried to search about it in the past. But what I ended up doing that has been working well is to keep everything documented. Every task and decisions are documented on .md files, referencing related tasks and decisions. The project becomes bloated quickly, but Claude can easily locate and relate decisions from a long time ago. Some times I even ask to do do something and mid-way Claude realizes that it goes against a previous written decision.
nkcodes 9 hours ago [-]
Yeah, I'm going to try this out the coming weeks.
I wonder if there are people around who have stories to share about de-AI-Slopifying a codebase.
toufiqqureshi 9 hours ago [-]
The same I was facing now I have built complete app but always worried about it is really protected and production ready I also facing this issue I don't know what to do
nkcodes 9 hours ago [-]
I'm going to try out having product specs committed in the repo itself - hopefully this gives every agent I spin up context into how the product is supposed to behave as opposed to having to "guess" it from reading the code adjacent to whatever prompt I gave it
mikewarot 1 hours ago [-]
I view any LLM generated code as a movie set, something that looks good, and has to last for one use. Use it like you would use Harbor Freight tools, as something to get a job done once, but not something to rely on.
LLMs can give you the API calls, and help you figure out how certain libraries work, but they're going to fail spectacularly on quality. I don't see any way around this for the next year or so.
The only positive suggestion I have is to keep the scope of your prompts tightly controlled. Be very, very specific in what you want, avoid wiggle room.
fwlr 8 hours ago [-]
I don’t think it is “you” that deals with this. You have outsourced your engineering to Claude, so Claude must deal with this, and if it’s not good enough to deal with that task just yet, you should wait for improvements to Claude until it is. (Some of the other suggestions here are good; it is possible that Claude already is good enough to deal with the task and you’re just not asking it correctly.)
0. Use Opus 5.5 on high.
1. Have in your CLAUDE.md the rule that code changes go together with updates to the docs. For me, that's HTML files in docs/. (Could be .md as well, but for human consumption, HTML is nicer.)
2. Have the rule that only that should go into the docs that an experienced engineer would need to rebuild the system from scratch, ignoring how it would look.
3. Larger work gets a plan doc in docs/plan, i.e. multi-PR work. There is a template how plans look, and an important part of the template is that the last step of the plan is always to delete the plan and fold anything from it that makes sense as long-term documentation into the docs.
4. Have a rule that before creating a PR, a sub agent needs to review the code, and have Codex Sol 6.1 high review it as well. Then let the main agent iterate on their findings until they are happy.
5. Every now and then, ask for an audit of the code. I ask for DRY, YAGNI, and KISS. Let it produce a report. Then let it fix all findings. If a lot, use a plan.
6. If you're adding something straight forward, just ask for it directly. If it's not, ask for a brief first. Review it. Then decide whether to implement in one go or through a plan.
7. Get an ultra plan, so you (mostly) don't have to worry about token usage but can use agents to their full ability.
8. Bonus and plug: Ask your agent to hand over with a demo video. It often finds and fixes issues while recording it, and you're not degraded to the agent's QA team, but it has to put in the work to convince you. I built a UI for directing agents as described: obeya.si. Free, open-source, local.
And the usual stuff any decent CI pipeline should have: tests, builds, linting, SQL breaking changes and potential heavy migration checks, etc.
A stronger version of this would be to make a separate gate. Fail the commit if the new code duplicates something already in a utility function, renames something that already had a name, uses for-loops instead of list comprehensions, whatever is bothering you.
1. Experiment and solidify architecture before adding features. I think this is the hardest step for top-down thinkers.
2. Heavy testing and benchmarking. Prefer to TDD as much as possible. The actual lines for my agent-written codebases are generally ~70+% tests, benchmarks, and experiments.
3. Full mutation test coverage after the code is written. Doing this as a human is miserable IMO, but robots make it reasonable. This step resolves SO MANY subtle bugs.
At that point my main role is ensuring alignment with the actual specs.
The trouble comes later when the "experimental features" actually start getting traction and we discover all the holes in our implementation.
By the time we need to "productionize" our experiment, it has already been patched all over the place to account for bugs.
I get a feeling that this is made worse by the fact that since a lot of what we're doing is rapid prototyping, our repo is cluttered with examples of bad code that the agent picks up on and then goes ahead to copy in its own implementation.
I get that we need to clean this up, but it's crazy trying to figure out where to start and what to tackle
> I get that we need to clean this up, but it's crazy trying to figure out where to start and what to tackle
Enumerate, then fix-or-nix all known examples of bad code first. If you clear the path first, you will advance more quickly. It can feel frustrating having to do that, but my experience is that paying off tech debt earlier will prevent hitting the wall at an inopportune time.
Pump out features and iterations as fast as you can until customers are buying your product.
Startups fail because they can’t find customers, not because their code quality is low.
Additionally, .NET added a bunch of formatting rules in its static analyzer for .NET 11 that give greater control on the styling of the code the agent generates. For example you can ban `=>` function syntax using editorconfig. The build will fail and the agent has to adjust.
[0] - https://github.com/con-dog/clingon
I wonder if there are people around who have stories to share about de-AI-Slopifying a codebase.
LLMs can give you the API calls, and help you figure out how certain libraries work, but they're going to fail spectacularly on quality. I don't see any way around this for the next year or so.
The only positive suggestion I have is to keep the scope of your prompts tightly controlled. Be very, very specific in what you want, avoid wiggle room.
It is an abstraction on top of code, turning your codebase into architecture diagrams and then keeping them up to date on each commit.
As a bonus you can do PR review and propose changes in it as well.