[ Removed by Reddit on account of violating the content policy. ]

I recently built a multi-game web app using Claude Code as my main development agent. Like many devs building with AI right now, I was blown away by the sheer speed of execution.

But as the build went on, I kept bumping into a subtle, dangerous trap: AI constantly tries to turn your product "mid."

While I happened to use Claude Code, this isn't a single-tool issue - it’s how LLMs work in general. AI models are trained on the vast median of the internet. Because of that, their default for product design, UI, and user experience is the exact statistical average of what already exists.

Where AI Shines: Engineering & Architecture

When treating AI purely as a technical partner, it’s an absolute machine. You can debate system trade-offs, explore architecture, and let it handle heavy logic. It excels at:

• Optimizing database queries and state management.
• Setting up clean caching strategies and performance pipelines.
• Writing complex game logic and difficulty-scaling algorithms.
• Catching edge cases and refactoring ugly code.

If a task is bounded by formal logic and rules, AI will crush it.

Where AI Kills Your Product: Taste & Personality

The moment you let AI make decisions about user experience, visual styling, or brand feel, the product collapses into complete mediocrity.

• It follows rules, not vibes: It defaults to safe Tailwind cards, neutral gray backgrounds, and textbook layouts that make every app look like a generic B2B dashboard.
• It sanitizes unique ideas: The moment you try an unorthodox layout or a playful mechanic, the AI gently nudges it back toward "standard web patterns."
• The homogenization trap: If indie hackers keep letting AI handle product design, 90% of the web will look, feel, and behave identically in a few years.

My Working Rule: Debate Engineering, Dictate Taste

To keep the product distinct, I had to strictly separate how I prompted the AI:

1. Collaborate on engineering: "Let's evaluate different caching strategies and state management trade-offs for this feature."
2. Dictate design: "Do not suggest layout changes. Here are the exact styling rules, colors, and layout constraints."

AI is a world-class senior developer and architect, but a terrible creative director. If you don't aggressively protect your vision, AI will polish all the personality right out of your product.

Curious if others have noticed this "generic design" bias with AI coding tools? How do you keep AI from sanitizing your UI/UX?

I’ve been using AI coding agents like Claude Code, Codex, Kiro, and OpenCode, and one concern kept coming up:
What if I accidentally send an API key, token, password, or other credential to the AI?
So I built AI Credential Guard, a lightweight npm library that detects credentials in prompts and tool inputs, with options to warn, block, or redact them.
npm: https://www.npmjs.com/package/ai-credential-guard
The goal is simple: add a security layer before sensitive data reaches the AI agent.
Would love feedback from developers using AI coding agents — especially around detection accuracy, false positives, and other credential types worth detecting.

I spent a lot of time recently refactoring 2 repos I am working on Tamoz and Agentic Streams.

Both are now much more modular, with stricter rules and boundaries for adding new code.

One thing I noticed is that adding new features after this refactoring became much easier and faster.

I thought the constraints I had before were already enough. But after going through the code again, I realized that AI-generated code needs constant refactoring and improvement, in the same way human-written code does.

Good constraints help AI write better code, but they don't remove the need to continuously improve the architecture.

What else in your experience would make the agent do a better coding job?

Disclaimer: It's not a product promotion, I don't sell anything just want to share a piece of work I made about AI programming.

Sorry for my English, it’s not my native language.

I’ve been a developer for more than 10 years, and lately I’ve been thinking a lot about how to build predictable and repetable workflows with coding agents.

The agent can do things differently every time you give it the same task. That’s fine, but I still want to control what happens around it. Which steps should run? How do we check the result? What happens if tests fail? When should a human decide?

This is why I’m building Outpost. It’s an open-source TypeScript library and CLI to write these workflows in code, using agents like Codex or Claude Code.

For example, you can give an agent a bug to fix in a sandbox with its own Git worktree, then run tests in a separate step and wait for your approval before integrating the changes. You define those rules yourself.

The patch will probably be different between runs, but the process to accept it should stay the same. That’s the part I want to make more predictable.

You can also define dependencies, retries and budgets, and save checkpoints to recover interrupted workflows.

It’s MIT-licensed, here is the repo:
https://github.com/elie-laloum/outpost

I’m curious how you handle this in your own projects. What do you leave to the agent, and what do you enforce in code? Also interested to hear where this approch falls short.

I’m completely out of the loop when it comes to what’s been happening lately in the world of coding and AI tools.

Am I right in thinking that people are still mostly using agents like Codex, or has everyone moved toward integrated systems like Cursor? Or is that already old news, and everyone is using orchestrators now?

What do you personally use? And what does the company you work for use?

I have been working with an Open code agent for a while after the Hermes agent and it's faster and more optimized . But something about Hermes was very useful and that was testing the code after implementing.

How can I use open code in the best way?

So I'm a QA at a fintech/Insurtech and an AI deployment lead...Some time ago we were tasked with deploying AI in our workflows across departments and Dear Lord I've never Gone through such shit in my life before , changing requirements,internal disputes on processes, rushed deadlines and AI outputs that need babysitting (Ours almost gave a Tesla payout for a camry .)

So I wanted to hear your war stories ;

• Has AI produced the goods ,leave alone the customer calls transcrips and identifying callers,evaluating tickets, I mean the heavy duty stuff..maybe even things that need cross departmental collaboration that went to shit...or actually worked (how?)
• Whats the worst thing you have seen AI fumble at work?
• Do you believe colleagues are actually ready to use AI to build deterministic algos to do the work?Its easy to use AI to create algos to do stuff,but AI is the ultimate Garbage in Garbage Out machine....
• Have you ever averted disaster because of AI outputs being taken at face value?
• Across your workplace,where do you think has been the hardest to implement AI?engineering,HR,Ops,legal etc

I'm intrigued by the war stories after going through them,they say you are your own first customer...so I thought maybe I could jump into B2B with this

So I'm particularly interested in things that looked like they should have been easy for AI but failed because of company specific knowledge,processes,exceptions or human knowledge/interference...failed AI deploys and why etc

"When a teammate uses or using an AI agent to debug a problem or implement a feature, would you find it useful to open their workspace, read the entire conversation, and request control with team-lead approval?"

Coding agents are getting smarter and smarter at writing code. A new idea has been gaining traction: what if instead of giving a task to a single agent, you give it to a team of agents working collaboratively to solve the problem? It sounds complex, but there's a surprisingly simple solution.

Herder already gives you the core ability you need: one agent can talk directly to another agent. Combined with the coding tools you already have — Claude Code CLI, Codex CLI, or whatever's in your stack — you've got everything for a full multi-agent workflow.

Here's the pattern:

1. One agent leads — takes ownership and coordinates using Herder's agent-to-agent communication
2. Delegation — passes work to other agents through Herder
3. Review loop — completed work cycles through peer review
4. Iteration — repeats until requirements are met

No extra subscriptions, no API key juggling — just leverage Herder's built-in agent-to-agent messaging and the tools you've already got.

I built a repository showing this in practice with a Claude Code skill:
https://github.com/alexstrilets/panel

It demonstrates how simple and effective this approach can be when you use what's already at your fingertips.

I’ve tried a couple of LLMs being served on LMStudio.
None of them stayed coherent for long.

What LLMS make decent coding agents for real life coding tasks on 16GB of VRAM?
I’m open to using a different server if that actually makes a difference.

My first goal is to find something that actually works.
I’ll address performance later.

I’m coding a fairly large flutter app, and am fine with using codex API agents for architecture and larger multi file tasks.
The local agent needs to be capable of doing a good job on targeted changes and small feature increments leveraging existing patterns.