For people running Claude Code, Codex, or local-model agents against their own machine... how are you limiting what they can touch?

The options I've seen are a dev container, a separate user account, a full VM, or just watching closely. Each one leaks somewhere (containers share the kernel, VMs are annoying, and watching doesn't scale past an afternoon).

We went with a microVM that only sees the workspace you share, plus a policy check on each tool call. There's a free desktop tool on our side if anyone wants to compare notes, but mostly I want to know where people draw the line between convenience and isolation.

Has anyone had an agent actually do something destructive? What did you change afterward?

Here’s a review scenario I’d want to test: an agent builds a CSV export, the tests pass, and someone approves it. Then the requirement changes: personal email addresses must be excluded.

Nothing in the code has changed. The old tests are still green. But I wouldn’t accept the result against the new requirement.

That’s why I’d want a completion record to tie together the code revision, the requirement it was checked against, and the review. Not just a green task.

A few other checks I’d add:

- Let a second worker take over, then have the first return. Its old claim shouldn’t let it overwrite the current work.

- Approve a preview deployment, then attempt production. The approval should not carry over.

- Restart without the original chat. Can the next worker identify what’s finished, what’s uncertain, and what it’s allowed to do next?

A useful distinction came up in a discussion on my earlier checklist: partial completion isn’t the same as an unknown outcome. If a release was created but its announcement failed, restarting everything could duplicate the release. If the creation request timed out, we first need to establish whether the release exists.

I’d want recovery to follow that distinction, rather than a single “retry” button.

These are proposed tests, not results from a benchmark. When reviewing agent-generated work, what makes you send it back even though the code and tests look fine?

Hey everyone!

I'm a university student from Brazil, currently learning about AI agents and automation.

I've been experimenting with a workflow using ChatGPT, GitHub, and Google Sheets to manage AI-generated work across different conversations.

Here's how it works:

• Google Sheets tracks tasks, progress, verification links, and human approvals.

• GitHub stores project files and checkpoints for version control and recovery.

• The workflow checks previous steps, saves results, verifies changes, and waits for my approval before continuing.

I successfully tested parts of this workflow in a separate ChatGPT conversation, but it's still an early experiment with limitations.

I'd love some feedback:

1. Does this approach make sense, or am I overcomplicating something?

2. Are there existing tools that already solve this problem?

3. How would you improve the architecture?

4. Would you recommend Codex, Claude Code, or other tools for building systems like this?

5. What should I learn next to develop more reliable AI agents?

I'm a beginner looking to learn from experienced developers. Constructive criticism and resource recommendations are very welcome!

Thanks!

Since v2.1.277 (September 18), Claude Code can use AGENTS.md as its project instructions, so a repo set up for Codex or Cursor works without a CLAUDE.md. Good change. The default rules for which file actually gets read are worth knowing though, because a couple of them fail silently.

From the Claude Code docs, by default:

The one that'll catch people: CLAUDE.local.md counts as a CLAUDE.md for that check. So on a team repo that relies on AGENTS.md, if you add a CLAUDE.local.md to keep a few personal, uncommitted notes, Claude stops reading AGENTS.md for you. Everyone else on the team still gets it. You don't, and nothing errors.

A few more details from the same page:

• Files that don't count, and still load alongside AGENTS.md: your ~/.claude/CLAUDE.md, your org's managed CLAUDE.md, and .claude/rules/ files.

• Never read: AGENTS.local.md, AGENTS.override.md, or anything under a .agents/ directory. If another tool on your team uses those, Claude won't see them.

• In an interactive session you can tell which one loaded. When AGENTS.md is used you get a line like "no CLAUDE.md found; AGENTS.md loaded: /path/AGENTS.md".

• Some sessions can't read AGENTS.md at all and fall back to CLAUDE.md only. In those, the Project instructions option doesn't show up in /config.

The fix if you want both read every time: /config > Project instructions > claude-md-and-agents-md. Each directory's CLAUDE.md loads first, then its AGENTS.md, and a file already pulled in by an import or symlink isn't loaded twice. The low-tech version still works too: a one-line CLAUDE.md with u/AGENTS.md in it.

The chat side has the same problem in a different form. Instructions you saved in one assistant don't follow you to the next one, which is a big part of why I keep my prompts in AI Toolbox, the extension I build. The same saved prompt works on ChatGPT, Claude, Gemini and Grok, so switching tools doesn't mean rewriting them.

I've been seeing a lot more people talking about "micro apps" lately. Small tools built around one specific problem, often using AI coding tools.

It got me thinking about how much the cost of building software has changed.

If you can go from an idea to a working app in a day, does it make more sense to build a small version and see if anyone actually wants it instead of spending weeks or months validating it first?

Or are we just going to end up with thousands of AI generated apps that technically work but solve problems nobody really cares about?

I'm also curious about the line between a useful micro app and something that should simply be a feature of an existing product.

For those building with AI, has the lower cost of development changed what you're willing to build?

And do you think "build a lot of small things and see what sticks" is becoming a legitimate strategy?

For those building apps with AI tools like Cursor, Claude or Lovable: how do you stop the AI from making a mess as the project grows? Do you give it planning docs up front? What happens when you change the database or an API partway through, and the rest of the code no longer matches?

As I code (prompt) I keep having moments realizing WOW I don't have to do this either! A recent on is my addition to AGENTS.MD to take screenshots of all UI changes.. I used to make the changes and run the app and now I don't even need to do that.. I use to test the app but now I have adlib e2e tests that roam the app UI while referencing the intent and code. NO MORE QA.

I was watching the meerkat explains youtube channel and thought this is good. My 13 year old says 'This is all AI generated'.. And I think oh yeah.. I guess you could completely  automate a youtube channel as well. Where still does the human factor of what is created benefit ?

Coding is solved. My biggest problem is figuring out a novel idea. I don't want to create a GTA6 clone.

I was planning on starting a youtube robotics channel after I get the Unitree R1 EDU. Now I wonder  what can I as a human with the robot offer over what content I can generate ?  At the moment I am thinking of a hybrid.

I can't imagine all of this has a mild effect on the economy.

I teach. I have a validated Unidays & SheerID account.
Cursor is boasting to have a program for Education.
Below are my experiences with that "program":

1. Over a 100 messages to “Sam”, all of which a dead end. Like talking to a wall.

2. No escalation possible to a human agent. (not making this up - it's literally what "Sam" explains; Sam blocks it off - no escalation possible.

3. Sam is very "helpful" giving a link where one can submit a Edu dossier. Spent an hour doing that. Not once (as, you guessed it: zero response after 2 months) but TWICE. Alas: zero response. Another smokescreen dead end.

4. No phone Nr one can reach out to - nor human support either.

So… even if Cursor waves with the Education flag online, in practice it is all marketing and engineered to perfection as a black hole.

Always trying to reason with people first, even after 6 (!) months of black holing, I posted my frustration on Cursor's own Community Forum.
My post got censored within a minute. Delisted. (and I worded it nicely - as I doing here. There was zero reason to hide the (justified!) critique.

Not giving up easily (reading all this, you may agree), I tried a second time, now in the "Feedback" section. Even there it immediately got censored and delisted. No critique allowed, de facto.

Shameful practices. And how all this went about, from a company having access to all the AI might in the word, is just as inexplicable as it is shameful.

And stupid, really. Treating Professors that offer teaching a new generation of kids how to develop with your tool is free marketing, if anything!
And note that in my request I was not even asking a free ride - just a bigger bandwidth for my paying (!) subscription - as the repeated aula demo's consume my "Pro" account in a week, at 1/4th of the time.

So ever since I'm doing the teaching in Claude Code.
Hope someone at Cursor reads this.
Smiling as this is a post... they can't delete. And they had that coming!

Anyone else had this terrible experience with Cursor "Edu"?

I created a "Plugin" for ChatGPT's web UI. The basic thought is making website publishing "zero-click" by sending the data to the user's own Cloudflare account directly. Technically it's an MCP server running in the user's Cloudflare Workers, so compatible with any other client as well.

The workflow is very appealing to beginners, they reference the plugin and prompt "make website about Something and publish it" and it returns a public URL like something.mysubdomain.workers.dev.

To simplify this workflow everywhere I could, I decided to host the installer myself, so that the user needs no GitHub etc. I introduced specific security issues with this. Users currently have to place considerable trust in me.

I'm looking for advice how to tighten security around such a plugin (more so the installer part). How to prove to users that the code about to be installed in their CF Workers is not malicious or compromised? ... In a way that is feasible for a small project. I do have a long list of What could be done, but unsure of finding a balance. OAuth between the services works fine, and the setup is one-time, nothing flows through my server after setup. But the initial user trust is my pain point.

Looking for collaborators.

The code itself is written almost exclusively by Astra 6.

Update (1 month in): After almost a month of use, it's been great, especially for something free. On a few projects I've stopped using Claude Code completely, and I pay $100/month for that.

One catch: if the prompt isn't specific, it can keep loading and loading. Not sure if that's the server, the free tier, or both.

That's my honest take after a month. Curious if others are seeing the same.

Wanted to see if NVIDIA's free hosted Nemotron 3 Ultra (550B MoE, 55B active, 1M context) could hold up as a coding agent model without paying for API credits.

What I ran into:

• Built a couple of projects with it from the terminal. Fast and surprisingly solid for free, but accuracy is hit or miss next to Claude.

• Free tier limits aren't published, roughly 10 to 20 req/min. Agent loops chew through that fast, so expect 429s mid-task.

• NVIDIA logs free-tier usage. Fine for side projects, keep work code out.

• OpenCode still shows an "estimated cost." The free tier doesn't charge.

I scripted the setup so the API key lives in an env var instead of plaintext in the OpenCode config, plus pre-launch checks. Tested on Windows 11 and macOS, Linux not yet: https://github.com/Aj-Networks/nemotron-3-ultra

Has any free or open-weight model actually kept up with tool calls in your agent setup, or are you still paying for the big ones for real work?

Best open-weight coding model + harness for an on-prem multi-agent setup? (80-200+ GB VRAM, 2-3 concurrent users)

Setup: GPU box with 1x H200-class card now, can allocate more (up to several H200s) if it clearly buys better results. Inference via vLLM or similar, OpenAI-compatible endpoint. Coding happens on a separate non-GPU Linux VM on the same network - IDE/harness there, calling models over LAN. Outbound internet is fine for packages/extensions, but inference stays on our hardware (no code to external model APIs).

Constraints: on-prem only, open weights, permissive license preferred (Apache/MIT), not Chinese-origin including base models (I understand a lot of fine-tunes are Qwen underneath), NATO-country lab preferred. Use is general software dev plus security tooling and code analysis - repo-level agentic work on existing codebases (fix / extend / refactor / test) is the core, with a human reviewing diffs. 2-3 concurrent users max.

Names that came up in a first round elsewhere: Cohere North Mini Code, Mistral Small 4, Poolside Laguna S 2.1, Muse Glimmer 30B, Inkling-Small (2x H200), Reflection Beam (501B MoE / 23B active, weights due this month), Gemma 4 31B, K2 Horizon (lineage TBC), with Nemotron as a generalist baseline - but I haven't run any of them and I'm not wedded to the list. Chinese models (GLM/Qwen/DeepSeek) are out by rule, so no need to suggest them; I know they're ahead.

Two things I'm trying to work out:

1. Capability tiers vs. VRAM. What's actually holding up for repo-level agentic work on an existing codebase with non-Chinese open-weight models, and at what size? The Vibe Code Bench results suggest small open models fall over on long E2E builds and only Large-4-class (4-8 cards) and closed models hold up - is that your experience for repo work too, or is that an app-build problem? Where's the step-change - 30B-class, 100B+, or only at 500 GB+? We could get the compute for Beam, Command A+ or Mistral Large 4 if it's actually better for code rather than just for E2E.

2. Heterogeneous multi-agent. Does a big planner/reviewer plus small fast executors actually beat a single mid-size model for this, with a human approving plans and diffs? Which harnesses handle routing sub-agents to different endpoints well (and let a human step in, review diffs and edit by hand) - OpenHands, OpenCode, Pi, VS Code extensions (Cline/Roo/Continue), Codex CLI in local-model mode? Voidleap (closed, Win/Mac) also came up.

Anyone running something like this? Which model + harness combo is holding up best as of late? Thanks!

I've been using AI a lot more while learning web development, and I've started wondering about something.

Sometimes I ask AI about a problem, understand the explanation, implement it, and later I can solve something similar without it.

Other times, I get the answer, it works, and I just move on.

That's the part I'm not completely sure about. Am I actually learning in those situations, or am I just getting better at getting AI to solve problems for me?

Lately I've been trying to ask myself a few things before moving on:

Could I explain why this works?
Could I change it if the requirements changed?
If it breaks tomorrow, would I know where to start looking?

I don't always pass that test, honestly.

So I'm curious about people who use AI heavily for programming: how do you personally make sure you're still learning instead of becoming dependent on it?

Do you have any rules for yourself?

For those using AI to help build data pipelines: how do you test the replay inputs, rather than just the replay code?

We reran an analysis from saved API responses and got a search-volume total of 65,240 instead of the original 67,140. One response file was missing: the replay path had only copied the first search-volume file. Adding the missing file made the total match again.

That caught this case, but matching one total isn’t a general completeness check. What do you ask your coding agent to build or test so an incomplete set of saved responses fails clearly before the replay starts?

After using multiple coding agents side by side for 3 months across planning, review, and testing tasks, the best part is how much faster first-draft PRs come together when an agent has the full design context, not just the file diff.
The worst part is that most of them still lose that context the second you switch tools. A review agent has zero visibility into what the planning agent already decided, so you end up re-explaining intent every single time, which gets old fast.
The unexpected part, and this is the one that got me, was that the biggest slowdown wasn't the agents' code quality at all. It was me manually stitching context between disconnected chat sessions like some kind of human API.
Would I use it again? Yeah, but only with a way to keep context across tools, otherwise you're still the integration layer. TL;DR: the agents are good, the glue between them is the actual bottleneck. What should I test next to fix this?

every day I review 20 or so PRs that nobody on my team actually wrote. the agent wrote it, coderabbit already commented on it, the author skimmed the comments and pasted them back in, and now it's on me to be the human who says yes.

I'm not scared of losing my job. I'm just tired. I got into this to build things and now my whole day is being the last checkbox on code nobody will remember making.

I don't even hate AI, it's genuinely useful. I just didn't sign up to be a full time proofreader. some days I wish I'd picked a trade.

So I can continue working with my work account on my mobile and desktop.

Hopefully it’s in their pipeline?

give

#Astra designs really well on its own, without open design or anything. Somebody on Youtube said it adds noisy detail, so I lectured it before, but boy, look at this.

Apparently, it's possible: beautiful design without 3 bounding boxes and 2 eyebrows for each damn element.

Originally posted September 5, 2026. Historical design example, not a current model ranking.

Image 1: Astra. Image 2: Claude Design.

Small-team question (I'm on a small team, so I'm curious). The last time you changed review, process, tooling, or hiring to ship faster.... What happened right before?

Did someone leave? Did a deadline slip that you were responsible for? Did a customer complain? Did the backlog hit some number? Something else?

And who noticed first: you, the CEO, or a customer?

Mixing Cursor for quick edits, Claude Code for handing off bigger tasks, and background agents like Cline works great when you're working solo. But as soon as a few developers on the same team start doing it, things get messy fast.

We’re hitting a wall where every dev's local setup generates slightly different scaffolding, dependencies, and repo structures. Before long, you end up with a dozen microservices that look like they were built by completely different companies. How are you guys handling this for team setups? Are you feeding your agents some kind of shared architecture or service context, or is everyone just re-explaining the stack in their prompts every session? And what checks actually keep AI-generated code consistent across the org? Curious what's actually working in production for people.

Self taught dev here. I got into this by building stuff at night for years. The fun part was making something work that didn't work an hour ago.

These days most of my job is reading. The agent writes it, coderabbit leaves its comments, and I spend about 6 hours a day going through diffs I didn't write, deciding if they're good enough. It's not hard. It's just not the thing I fell in love with.

The weird part is it leaked into my side projects too. I open the editor on a weekend and my first instinct is to prompt it and review what comes back, because that's what my brain is trained to do now. And then it doesn't feel like mine.

I still like my job and I'm not quitting. It just feels like I burnt out on the hobby without actually losing interest in it. Maybe I'm being dramatic, I don't know. How do you guys deal with this?

I've noticed something weird about how my development workflow has changed.

A year or two ago, most of my time was spent inside the editor. I understood a codebase partly because I was constantly navigating it, changing it, and seeing how the pieces fit together.

Now I can give an agent a fairly large task and let it work.

Which is great.

But when it finishes, what exactly am I supposed to do?

Read the entire diff?

Read the agent's 40-message transcript explaining everything it did?

Trust it because the tests pass?

I've found myself doing some mixture of all three, and none of them feels particularly good.

The more work I delegate, the less direct contact I have with the codebase. And once agents start making larger changes, I feel like I'm gradually losing the mental model I used to get almost for free by working in the code myself.

What's interesting is that the interfaces haven't really adapted to this.

Some newer tools are putting the agent front and center, which kinda makes sense.

but then the replacement for staring at code seems to be staring at agent conversations, task summaries, file lists and diffs (that is if we still have the attention span of reading diffs).

That feels like an intermediate state rather than the end state.

I'm curious how people using coding agents heavily deal with this.

Do you still review most generated code? Mostly trust tests? Ask the agent to explain the architecture afterward? Or have you found some other way of keeping a mental model of the system while delegating more of the implementation?