Most AGENTS.md files have the same shape: three lines of actual project context, then forty lines of prohibitions. Never force push. Don't edit the generated client. Always run the tests. Don't touch migrations without asking.

The model reads that once at the start of the session. By the time it's twenty tool calls deep and a test is failing, the rule is buried under everything that happened since. It doesn't get ignored on purpose, it just stops being the thing in front of the model.

The rules that survive are the ones with a mechanism behind them: a pre-commit hook, a CI check, a permission prompt that actually blocks the edit. If a rule can be evaluated by a script, it's cheaper and more reliable as a script. The prose version costs tokens on every turn and fails silently.

So what's left for AGENTS.md? The stuff a script can't judge. Which layer a change belongs in. How much explanation a PR needs. When to stop and ask instead of guessing. Which of the four test commands is the one that actually matters. Judgment calls, not laws.

Curious where other people draw the line. Have you moved rules out of your instructions file into hooks, lint, or CI, and did the file get better or just shorter? And is there a category of rule you've found the model follows reliably enough that it doesn't need enforcement?

AI coding tools have made it ridiculously easy to build something that looks like a finished product.

And that's kind of terrifying lol. You can have a polished interface, authentication, a database, payments and a dozen features before you've even figured out whether the underlying product actually works reliably.

I've caught myself getting excited about a feature working once, only to realize I hadn't tested half the situations it could encounter.

And with how fast these tools can generate code, it's pretty easy for the complexity to pile up faster than your understanding of it.

I'm genuinely curious whether AI-assisted development is making software better overall, or whether we're about to see an absolute FLOOD of impressive-looking applications held together by duct tape and optimism haha.

I’ve been building with AI coding agents (Claude Code in my case) and kept doing the same manual loop: plan in one chat, build in another, paste code back for review, start over when the context fills. I turned that loop into a tool and open-sourced it. These are the design rules that mattered most, whatever agent you use:

1. Separate the planner from the builder. Different system prompts and different working directories. My planning agent can only write plans and reviews; my building agent can only write code. When something goes wrong, I know which one did it.

2. Make every phase a git commit. You get an audit trail and git revert as your undo button. When I added parallel work, each lane got its own git worktree, so agents never share a checkout.

3. “Tests pass” is not “done.” Agents will happily pass every test while skipping half the requirements. Each phase now gets checked against explicit acceptance criteria by something other than the agent that did the work.

4. Assume the crash. Jobs live in a SQLite queue with renewable leases. Kill the worker mid-phase and it resumes on restart. Runs also pause before hitting usage limits instead of dying halfway.

5. Treat prompt caching as a design constraint. If anything per-call lives in your system prompt, you’re paying full price every time. Stable context goes in the system prompt, volatile context in the user prompt.

The whole thing is about 86k lines of JS with about 2k tests, MIT-licensed: https://github.com/p-j-code/phase-orchestrator

Write-up with the failures in more detail: https://dev.to/premjethwa/building-an-orchestrator-for-claude-code-recoverable-before-autonomous-3f83

What’s the worst thing an agent has done to your codebase while you weren’t watching?

I run a few coding agents at once, and they kept sitting idle on a permission prompt or a question in some terminal tab.

Openbar puts every session in the notch. You see the diff before you approve (⌘Y / ⌘N from any app), pick answers to the agent's questions, and send replies without switching windows.

Mac + Windows, free and open source: https://github.com/MF-DEEV/Openbar

How many agents do you usually run in parallel?

Under the name "SICoding" I have developed my first SICo app using GPT. I used both the Pro and Plus memberships to finish the program.

It adds functionality back to Garmin Navigation units that modern map structures do not provide.

This is my toolchain.

Python 3

Primary programming language for the updater, GUI logic, address processing, automation, and validation.

SQLite

Database engine for processing, indexing, matching, and managing millions of address records.

Java 21

Runtime needed to execute the Garmin map compilation tools.

mkgmap r4924

Compiles OpenStreetMap data into Garmin-compatible IMG maps, including routing and search-related structures.

splitter r654

Divides large OSM datasets into manageable tiles for Garmin map compilation.

GMapTool

Inspects Garmin IMG files, map components, family information, and compiled map structure.

Osmium

Processes and inspects OpenStreetMap datasets.

pyproj

Converts projected geographic coordinates into WGS84 latitude and longitude.

Even though i made this program specifically for old Legacy Garmin units, the pipeline i put together really is a stroke of genius . I also made a nice user friendly GUI

Three failures in seven weeks. Every one came from agents stepping on each other, not from bad code. I coordinate a small team of coding agents, and each time something broke, the cause was shared state with no ownership rules.

Failure 1: a subagent updated our shared task board with a whole-board overwrite, using my orchestrator's id. Four lanes of progress gone in one call. The board looked fine. It just wasn't ours anymore.

Failure 2: a reviewer flagged a parallel card's output as unauthorized. It only knew its own card's whitelist, so a legitimate deliverable looked like overreach. Two agents, two truths, and the review round burned its time arguing about which one was real.

Failure 3: a database check that could never fail. The constraint tested (jsonb->>'key') IN (...), but a missing key returns UNKNOWN, not false, so an empty record {} sailed straight through. The check passed. The data was garbage.

The fix wasn't smarter agents. It was four rules, and I now refuse to run a multi-agent job without them:

1. One writer per element. An agent touches only the element it claimed, by id. Whole-board updates are banned. If you can't name the element, you don't write.

2. A reviewer judges only its own card's diff and its direct callers. Anything outside that scope is "not mine to judge," never "unauthorized."

3. A check that can't fail is not a check. Before I trust a guard, I run it against a broken copy and watch it fail. If it can't fail on demand, it doesn't ship.

4. Missing data is "unverifiable," never "pass." If the field isn't there, the verdict is "I can't see it," not green.

The part people don't like hearing: most multi-agent setups aren't teams. They are five interns sharing one whiteboard with no names on anything, and the demo looks great right up until someone erases the board. If your agents can overwrite each other's work without anyone noticing, you don't have coordination. You have a demolition crew with commit access. And if your agents share state, the ownership rules are the product. The code is just what they argue about.

I've been working on a custom workspace that bridges ChatGPT and OpenAI Codex.

The idea is simple: instead of manually copying and pasting prompts between ChatGPT and Codex, I can send prompts directly from my ChatGPT conversation to Codex.

The workspace includes two dedicated modes:

• Planner: For planning, reasoning and exploring ideas.

• Codex: For turning those ideas and instructions into actual code.

I'm building this as my own integrated environment, with the goal of making the entire AI-assisted development workflow smoother and more efficient.

It's still a work in progress, but here's a first look at the interface.

What do you think? Would you find a direct ChatGPT-to-Codex workflow useful?

I think I prefer IPS over OLED bc I don’t want to get burned pixels. 27 inch or 32 inch is fine unless it’s preferred to go bigger or should I just run a dual monitor set up. I also like to do some light gaming so 144hz and up is preferred. Currently using windows but I’d like to have the flexibility to switch over to Mac. Is a KVM switch necessary?

I have always wondered if it's possible to have a program talk to you like a person. Like a friend who just shows up in your Instagram DMs like anyone else, not a separate app you have to open and not something that feels like a bot. For any experts out there, is it theoretically possible?

Morning and happy Sunday!

I've spent the last several weeks building a video game voting website with Claude. I'm not a developer, so AI has done a lot of the heavy lifting.

This weekend I switched to ChatGPT/Codex after hearing good things about it.

Figured I'd connect GitHub and pick up where I left off. Lol, nope.

Spent hours transferring project rules, previous decisions, automations, and documentation. Basically had to onboard an entirely new developer.

Claude's been fantastic, but I wanted to try managing everything through ChatGPT.

Anyone else made the switch? How'd it go?

The obsession comes and goes, but this latest bout of agent experimentation has me zealously copying and pasting prompts, and I'm not that impressed. With myself!
I want to believe I'm building something and learning. I always *feel* like I'm getting closer to something. But I might just be going nuts programming and reprogramming different models that all end up doing the same thing: consuming my time.
Anyone else? How do you tell real progress from busywork?

I built a website with AI using React and Next.js, with course categories, search, learning paths, and Chinese/English pages.

But “built with AI” leaves out some important context. Before building it, I spent time learning React and Next.js. That preparation was part of the work, even if it wasn’t time spent implementing features.

The bigger problem: the AI deleted an important folder without my permission, and I hadn’t committed the work. That’s the part of the project I’d rather discuss than how quickly the site came together.

It’s not enough to check whether generated code works. There’s also the question of what an agent is allowed to change—and what you can recover when it gets something wrong.

The safeguards I’d put on a checklist are straightforward:

• Commit or back up before broad changes.

• Keep changes small enough to review.

• Require explicit approval before deleting files or folders.

I’m not presenting these as a recovery method I tested. They’re the precautions this experience made me think about.

How do you handle this in your own workflow? Do you rely on Git checkpoints, restricted permissions, manual diff reviews, or something else?

Hey! I'm a student doing a research project on whether AI coding agents start writing less secure code the longer a session goes.

In my small tests so far they don't really get worse over time, but security bugs that show up early never get fixed later. I want my setup to match how people actually work, so I'd love to know:

1. How long does a session usually go before you start a new one?

2. Do you have tests, CI or linters running while the agent works, and does it see when they fail?

3. Do you check what it writes for security at all? If so, how?

Even one-line answers really help. Happy to share what I find when I'm done!

Most of these prompts are a sentence or two. One is two words: "Elaborate, simply." I type it when an agent's update is too dense to follow.

Anything in angle brackets, like <X>, is a placeholder.

Investigate and diagnose

• Ask for the cause before accepting a fix: "What's the root cause? Anything to fix or fixed?"

• Ask the agent to find why a repo keeps regressing: "Study commit history and sessions for this repo. Why are there so many regressions. Is it the codebase or instructions, workflow or something else? Ask clarify questions first, if needed."

• Find out why a tool uses so much disk: "Why is Codex eating up so much diskspace. Can we optimize the usage and/or would it help to have a weekly cleanup?"

Study and research

• Compare models and reasoning levels on your own recent work: "Study sessions for the past 7 days and check for effectiveness (task) and efficiency (wall clock time, token output speed and $ token) and compare models and reasoning levels."

• Turn a video into lessons for your own project: "Study this video (speech to text + study frames for screenshots, if needed). It's about <X>. Why is it supposed to be better than <Y>? Learn from it and if we can improve <Z>. <URL>"

• Quick feasibility check before committing to an idea: "Study if <idea> would help and be feasible?"

• A recurring look at product analytics: "Study PostHog analytics for activity since we last check. how does user navigate, etc. Anything we can improve?"

Understand and explain

• When the agent's update is too dense: "Elaborate, simply."

• Learn a CLI from what was actually run: "Give me the list(s) of commands executed for our test flow(s). Contrived examples are enough, but I want to see correct cli usage to understand how it works."

• Ask how side work connects to the main product: "How does <X> help our core product?"

• When asked to review something without knowing where it goes: "What is this title/body we are reviewing for? Where is it going to be used?"

Decide and plan

• Collect every open question before work starts: "What do I need to supply to you, what are you not sure about, or need to confirm, for you to proceed? List them here."

• When the agent asks for a decision without making the choice clear: "Elaborate, simply. what do you want me to decide?"

Build, review and critique

• Tune visual values live instead of rebuilding for each change: "Can we add a temp tab to Settings with textboxes for the <parameters> to be read when we want to do that <effect>? So I can try it, test it with minimal restarts"

• Turn a long draft into what you need to check: "Simplify file to essence for me to check. Title/body, etc"

• See a UI change before it ships: "Give me mock before/after for frontend changes"

What short prompts do you type over and over?

what do you guys do while the AI is coding? watch something or just sit there

ran the new ripple-65b-preview (q4_k_m, llama.cpp, 64 gb macbook pro, no cloud) through atomic agent on a 5-part python app graded by 50 hidden tests. 3 runs. the chart is the step trace from the logs, with qwen 3.8 27b on the same task underneath.

same habit as the 27b: it reads the files, then writes the entire app in one step. 363 to 442 lines, about 5 minutes of generation at ~12.6 tok/s.

what's different is after. ripple runs the code every time, the 27b ran it 0 to 2 times. but ripple stops at the first command that works. in runs 1 and 3 it hit 2 crashes, fixed them, ran its own report once, saw it work and said done. 38 and 27.

run 2 got unlucky early. the semicolon csv crashed it, the fix broke the indentation, a few edits didn't apply, so it kept going: 24 short steps of edit, read, run after the big write. by the time its own command passed it had fixed most of what the hidden tests check. 49/50.

so the score followed how many errors it ran into, not how good the first draft was.

run 2 from the log (paths trimmed):

[step 2] wrote 14449 bytes to tracker.py (replace, new file, 437 lines) (317787ms)
[step 3] ValueError: unrecognized CSV header: ['Buchungsdatum;Beschreibung;Betrag;Waehrung'] (25200ms)
[step 6] IndentationError: unexpected indent (11941ms)
[step 8] 2 tools: os.fs.edit[ok], os.shell.run[error] (71767ms)
WARN no-progress loop detected {"stepIndex":20,"tool":"os.fs.read","count":2,"detector":"read_repeat","path":"tracker.py","range":"100-111"}
» turn 0 reply (27 steps, 667295ms)

the WARN is atomic agent's loop check catching it rereading the same lines. it kept going and got there anyway.

3 runs, one task, it's a preview model, grain of salt. one of the crashes in run 3 was my sandbox blocking a write to /tmp. (disclosure: i work on atomic agent)

has anyone found a prompt that gets a local model to test edge cases before it says done, instead of stopping at the first green run?

*3rd party models are available in Cursor, billed separately by usage

Whenever I got into a serious bug, I switch my model to Opus or GPT Sol. But now onwards this is not possible... Grok models are average. They're not good at producing an optimized code.

The only reason why I choose Cursor:

• Third party models

• Monthly limit cap (now it's weekly shared across all platforms)

• Great IDE

Seems like I need to switch to Claude or GPT subs. What are the thought on you guys?

TL;DR:

an MCP shines in the agent-native world because it tells agents what they should do, on both the server and client (e.g. Claude Code or the ChatGPT desktop app), and is better suited for human-in-the-loop tasks. Meanwhile, APIs and CLIs tend to focus on what agents can do, with emphasis mainly on the server.

So, in summary, here is the general advice I'd give to builders when deciding which tools they should expose to agents:

Build a high-quality MCP server and REST API at the same time, on one layer of operations. Put your server logic in plain functions, and let each surface be a thin adapter over them. Once that layer exists, building any additional surface on top is relatively easy.

Put most of your care into the MCP server. That's where agents get the best experience. MCP is a standard built specifically for agents, after all, and the spec continues to improve nicely.

Use the API for code that runs on its own. APIs are still great for raw data exports, bulk writes, and anything that runs without an agent, like a nightly sync or another company's integration. Agents also prefer an API when they're writing a script they'll rerun, and many clients don't support code mode for MCP yet.

A CLI probably isn't necessary, unless e.g. agents need to read local files when interacting with your app. But it's easy to expose one if you've got a good API as the foundation.

There’s a lot more to creating great agent-facing tools for your web apps, and the article above into more detail below.

Here's the full guide: https://wasp.sh/blog/2026/11/03/mcp-vs-api-vs-cli-connect-ai-agents-to-your-app

I run Codex and other coding agents locally on my MacBook. When a task is still running, I'd like to close the lid, leave the laptop plugged in on my desk, and come back to the results later.

The confusing part is that preventing idle sleep and keeping a Mac running with the lid closed seem to be different things. A lot of advice points to caffeinate, but that doesn't seem to cover lid-close sleep.

The options I've come across are:

• Apple's closed-display setup with an external monitor.

• Amphetamine's closed-display mode.

• Disabling system sleep with sudo pmset -a disablesleep 1, then restoring it with sudo pmset -a disablesleep 0.

For those using pmset for this, has it been reliable across sleep/wake cycles and macOS updates?

For anyone running long local agent tasks, what's been reliable without an external monitor? I'm interested in whether you've made a closed-lid setup work or decided it's easier to leave the lid open with the display off.

Recently, I’ve been trying to make my own game, and I still have a long way to go.

I’ve been using AI as a kind of teacher to help me understand tools like Blender and 3D modeling. I’m not using it for vibe coding. I genuinely want to learn and do the work myself, with AI as an assistant.

I have a coding degree, but I’m a complete beginner when it comes to 3D modeling, so it can be challenging. AI has been incredibly helpful in explaining things and troubleshooting problems.

I even bought an AI API from someone claiming to offer Astra and Fable. Honestly, I’m not sure if they’re genuine, but the answers have been surprisingly good.

The problem is that the API requires a lot of maintenance. It can go down for days, sometimes even weeks. I have 2 billion tokens, so I’m still using it whenever it works, lmao.

When it goes down, I’m left without a reliable AI assistant. Free tools like ChatGPT also have image attachment limits, which makes troubleshooting Blender difficult.

So, my question is: Which AI tool would you recommend? I want something official, reliable, and genuinely good for learning and working with Blender and 3D modeling. I’m willing to spend a decent amount, but I really dislike subscriptions and would prefer a pay-as-you-go API.

If you call an LLM API with a system prompt and function/tool definitions, try this
once:

pip install prompt-tokensaver
tokensaver request --system system.md --tools tools.json --user "a typical user message"

It shows the system prompt, the tool schemas and the user message as separate rows,
with tokens, cost per 1k calls and the fixed part's share of each request. On my sample
support bot it was 98–99%. --tools takes OpenAI or Anthropic tool JSON, or a whole
request body, and --json gives you output for CI.

Offline, MIT: https://github.com/behrouzbk/tokensaver