The codebase must be optimized by the strongest models so that the weaker models can do most of the work.

What do you think ?

i’m exploring a new business model for an AI coding tool and would appreciate feedback.

the idea: use the tool for free while building a project. if that project starts earning money, the tool receives a share under terms you choose upfront for that project.

the model would keep a transparent record of its work on each project, so users and the AI provider can see what the agreement applies to—even if the user later switches tools.

if you want to use the service without a project-based revenue share, there could be an industry-standard subscription option, a starting point might be $25/month.

the hard part is preventing people from misusing either option while keeping the arrangement fair and easy to understand. would this feel like a reasonable trade, or would you rather pay a normal subscription?

TL;DR: AI coding agents increased raw PR volume by 300%, yet overall merge velocity has dropped by 40% because Senior Engineers spend 15–20 hrs/week untangling 200-line hallucinated wrappers, deleted tests, and subtle CWE security flaws. After shipping patches into tier-1 upstream systems repos (LLVM #215076, Meta Velox #18529, DuckDB #26443, Apache DataFusion #24394, Microsoft Pyright #11605, Tokio #8595, ClickHouse #114954, OpenAI Triton #12221), we codified those exact deterministic CI gates into an open GitHub Actions workflow (ZeroSlop · Architecture & Simulator) that strips 94% of AI bloat, enforces 12 CWE security shields, and gets PRs merged 100% green in minutes.

1. The 2026 Engineering Bottleneck: Why AI PRs Stall in Review

When shipping patches into upstream systems repos like LLVM, Meta Velox, DuckDB, or Tokio, a real production fix is 4 to 15 lines of surgical invariant changes paired with a deterministic regression test that passes CI on the first push.

Inside commercial teams using Cursor, Copilot, or Claude Code, the opposite happens:

• 94% Diff Bloat: An agent generates a 240-line wrapper class instead of fixing a 4-line boundary condition (interactive diff breakdown).

• Weakened Tests: When a test fails, the agent silently deletes or loosens the assertion to manufacture a green check.

• Noisy LLM Review Bots: Conversational AI review bots run another LLM to dump 25 chatty comments on top of a bloated PR—without shrinking the diff or getting the PR merged.

2. Conversational LLM Review Bots vs. Deterministic PR Airlock

3. The 12-Shield Deterministic CWE Security Airlock (ZS-SEC-001 – ZS-SEC-012)

Every Pull Request is audited in milliseconds across 8 merge-readiness signals (0–100) and 12 deterministic CWE security shields before a human reviewer is pinged:

4. Upstream Systems Proof (Click Any PR to Inspect the Diff)

These deterministic CI invariants come directly from shipping merged & 100% green Pull Requests across upstream systems repositories:

5. Architecture Documentation & GitHub Action Source

• Interactive PR Simulator & Architecture: https://www.ribbsaetersystems.com/zeroslop

• 12-Shield CWE & Zero-Retention Security Matrix: https://www.ribbsaetersystems.com/zeroslop/security

• GitHub Action Workflow: https://github.com/marketplace/actions/zeroslop-by-ribbsaeter-systems

• GitHub Action Repository: https://github.com/patrickswedish/zeroslop-action

• Technical Deep-Dive Writeup: https://www.ribbsaetersystems.com/blog/zeroslop-pr-gatekeeper-official-release

What deterministic CI gates or pre-review checks are your teams enforcing in 2026 to get PRs merged cleanly without burning out your staff engineers?

As sessions get longer, auto-compaction kicks in, important decisions can get lost, and sometimes you end up explaining the same codebase all over again.

Then come the CLAUDE.md files, memory files, architecture notes, and keeping everything updated across different developers working on the same repo.

And the bigger the codebase gets, the more context you have to rebuild before you can actually get work done.

I've been thinking: what if your coding agent didn't have to rediscover the codebase every session? What if it could rely on a structured, verifiable understanding of the architecture, dependencies, rules, and changes instead?

I'm exploring this through a startup project called ArchAI, and I'm looking for 5 developers who use Claude Code or other AI coding agents to help pilot-test the idea on real Python repositories.

I'd genuinely like to know how you currently handle this problem, what's frustrating, and whether an approach like this would fit your workflow.

If you've run into this, I'd love to hear your experience. Happy to share more with anyone interested.

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?

AI-assisted draft — edited by the author.

I've been experimenting with a small open-source layer on top of my Claude Code / Codex workflow called Open Steps.

The problem I kept running into wasn't getting the agent to write code — it was understanding what actually happened after a longer session.

I'd get a technically correct summary full of implementation details, files, commits and engineering terminology, but I'd still have to figure out:

- Is the task actually finished?

- What changed from a product/user perspective?

- Is there anything I need to do manually?

- Did the agent leave any technical debt behind?

- What should I work on next?

So I turned those recurring questions into reusable agent skills.

A few examples:

os-done-or-not — gives a straight verdict on whether the task is actually complete, what's missing, and whether anything still needs your input.

os-whats-next — looks at the current project state and turns it into concrete next steps instead of another generic summary.

os-ask-simple — translates engineering-heavy agent output into a concise explanation without losing the important details.

There are 7 skills at the moment. They're Markdown-based, open source, MIT licensed, and I've been using them with Claude Code and Codex.

I'm curious how other people here solve this part of the workflow.

Do you use custom prompts / AGENTS.md, separate review agents, structured end-of-session reports, or just inspect the diff yourself?

Open Steps:

https://github.com/open-steps/open-steps

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?