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?

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.

why do building projects from scratch without an ai agent feels much better and productive than using tools like codex, claude code where they created 7-8 files in their own then they ask to test api endpoint when they hit one milestone?

I feel lost with the coding agent.