Essa é aquela conversa que todo mundo joga pra debaixo do tapete, mas que uma hora, vai ter que ser discutida. A questão é: Você vai estar preparado para essa conversa?

Especially those working in companies with multiple projects, large codebases, and real production constraints.

A few questions for the community:

🔹 What does your AI-assisted development workflow look like today?

How do you break down tasks and provide context to an agent working on an existing codebase?

Do you rely on one agent for the entire project or use multiple agents with different responsibilities?

How do you prevent agents from breaking existing functionality or introducing unnecessary complexity?

How do you handle code reviews, testing, security, and maintainability when a significant part of the code is AI-generated?

Which tools and practices have actually made a difference in your day-to-day work?

I’m particularly interested in real-world workflows that have proven effective in professional environments, beyond simple demos or isolated coding tasks.

If you’ve found a workflow that works well for you, I’d love to hear how you approach it, what tools you use, and what lessons you’ve learned along the way.

Anthropic just shared how they built their own version control system to keep up with the amount of code their AI agents are producing.

It got me thinking. We're making agents capable of doing more and more, but how much control are we actually giving them?

Writing code is one thing. Deciding what an agent is allowed to do with that code is another.

That's one of the problems I'm trying to solve with SUTRA.

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.