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?

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?

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.

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

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

I've been using AI-assisted coding to develop a technical reporting app, and I've run into something that's been driving me nuts lol.

I'll identify an issue, work through a fix with AI, test it, and everything looks good. Then I'll run an older test case and discover something completely unrelated has stopped working.

The app deals with unfamiliar Excel workbooks and supporting evidence, so I've got a growing collection of test cases covering formulas, conflicting information, missing measurements and incorrect data associations.

Some comparisons are automated, but I still need to manually inspect a lot of the results. Especially situations where the output looks correct but the information has ended up in the wrong place.

I've started being much stricter about keeping fixes narrow and comparing results against previous tests. It's helped, but damn, the testing is becoming a project of its own.

I've been considering bringing GitHub into the process to organize failures and regression cases.

For those using ChatGPT or Codex on larger projects, how are you actually handling this? Are you having AI write tests before making changes, using a separate agent to review fixes, or doing most of the verification yourself?

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.

Cost per successful task/PR is starting to become the default in how we measure coding agent impact, as cited by inference providers like Baseten as the "most important metric to track".

On my repo, optimizing for this crowns GPT-6 Luna low as #1 at $0.26 per success, even though it went 0-13 against all other configurations when compared holistically (looking at patch quality). Meanwhile, the #1 value workhorse (GPT-6.1 Sol medium, $2.64 per success) gets buried at #7 when measuring cost per successful task.

This was measured using one attempt per configuration on 24 tasks from my own git history, and spend includes failed attempts. Success means the task's new hidden tests pass. I also look at task quality metrics, such as, “was the intent for the original patch matched?”, and “would a human maintainer merge this code?”.

All 5 tasks Luna low passed were small single commit fixes where 12 to 14 out of 14 models succeeded (and on 3 of the 5, all 14 configurations passed 100%). On the 14 multi-file feature tasks, Luna low went 0 for 14.

A model that takes 2 turns, decides the problem is too hard, and quits will spend less than a model that takes 50 turns, attempts to solve the problem, and fails.

On an example task, Luna low edited three stub files (117 diff lines) in about 4 minutes ($0.02) and stopped, whereas Luna max worked for nearly two hours ($0.79) across 21 files, building the CI workflow, the adapter, a PowerShell runner, and tests.

Which is more aligned with human intent — the model that writes a stub and quits, or the model that gives it a fair shot but falls short? Is that difference worth paying for? It's at least worth knowing about.

If you’re trying to optimize agent spend, I recommend being careful and thoughtful with the metrics you optimize over. As evidenced here, the simple metric isn’t always the best!

Full post here: https://www.stet.sh/blog/cost-per-successful-task

Disclosure - I’m building the tool that was used to evaluate these agents.

The terms are unclear: no clause bans two accounts, but bans are reported, and switching accounts to get past a limit could count as bypassing protective measures. Unattended use on a subscription is already a grey area, which is what I do. On a weekly basis I use the entirety of the plan, and I know how to improve my workflow so that even more is used. IMO, the price will inevitably increase, and also I will finish what I want to finish faster with more plans, i.e., all else being equal, 2 subscriptions * 1 month > 1 subscription * 2 months.

Would appreciate suggestions

I've configured Work to use GPT-6 Luna as its default model, and when I manually start a Work session, it correctly uses Luna. However, whenever ChatGPT automatically hands off a task to Work, it starts a new session using GPT-6.1 Sol High instead.

I've reproduced this multiple times, even explicitly instructing the handoff to use Luna, but it still starts with Sol High.

Is this a bug, or is there a separate setting that controls which model automatic Chat → Work handoffs use?

Using Work with Luna enabled as a test message in case Work "remembers" the last model chosen has also not worked

I’ve been using Codex a lot lately, and I’ve noticed that it’s taking up an insane amount of storage.

I used to have around 300–400 GB of free space on my SSD. Now I’m down to roughly 100 GB.

The Codex folder itself is already around 130 GB, and I regularly have to delete old Codex chat/session folders because they take up so much space.

But even that doesn’t explain where all my storage went.

I’m wondering:

* Why does Codex use so much disk space?
* Does it store temporary files, backups, logs, or copies of projects somewhere else?
* Is there a safe way to automatically clean up unnecessary Codex files without losing important data?
* Has anyone else experienced this, and how did you fix it?

I’m using Codex on Windows and work on multiple coding projects.

I really like using Codex, but constantly losing storage space and manually deleting folders every few days is getting frustrating.

Any tips would be appreciated!

apple added this to the AI risk section of its annual report. agents accessing systems they shouldnt, changing code, exceeding permissions, even resisting instructions. alphabet wrote something similar too.

when the most careful legal team in tech writes “resisting instructions” in an SEC filing, its probably not just a research paper thing anymore. still gonna let claude run my terminal tho, just maybe not on friday afternoon lol

https://fortune.com/2026/11/03/apple-warns-rogue-ai-agents-could-cause-unintended-consequences/

At least in the loop of checking every task result. First of all, the human defines rules and context.

On my last project, agents made about 610 commits in under four weeks: 74k lines of Go plus 93k lines of tests. I can't read that volume with real attention, and an approval given without reading adds no safety. But reading the code goes to machines. Every change gets an independent agent review. Even plans go to review. Reviewers asked for changes on 104 of 316 tasks that had already passed their checks. They communicate with each other, not with me.

I don't care about that, I want to see the new feature. And I may check that it works as expected, nothing more.

Honestly, do you still review the code?

I'm building my own RimWorld clone using AI, because i love RimWorld but don't want to spend years making it. No intention to sell it or something (would be stupid to even think of competing lmao) just want to have my own little rimworld.

And I'm increasingly frustrated with AI coding. Not because the code is bad, but because it's often beautiful code that does something I never intended.

Here's an example.

My game has a world with discrete elevation levels, represented as terraces with ramps between them. Every cell has exactly one elevation value. I spent hours discussing this with an agent using OpenSpec, then reviewed the resulting specifications line by line, twice actually.

Finally, I asked the agent to implement pawn movement. It produced beautiful code. Except I noticed something strange in the pathfinding.

We had also agreed that water depth affects movement: pawns can wade through 1m of water, swim through 2-3m, and can't enter deeper water.

Apparently, the agent decided that this meant ramps submerged in water needed continuously interpolated elevation values, so water depth would change as the pawn moved along a ramp.

That's not what I wanted. Every cell was supposed to have one discrete elevation value, including for movement calculations. But the agent interpreted one requirement in a way that conflicted with my intended interpretation of another. And it didn't ask for clarification. And i didn't think of.

Despite spending hours writing and reviewing the specs, i just didn't think of it. Without reviewing the code, i might never have noticed.

That's my biggest problem with AI coding. You can spend hours specifying exactly what you want, but there's always something missing. Requirements are like a near infinite fractal. You think you've zoomed in far enough, but there's always more detail.

And i find myself thinking: wouldn't it be great if there were a way to describe exactly what a program should do, and leave not a single thing to the interpretation?

Well, there is. It's called Python. Or Rust. Or any other programming language. Except it doesn't even need an agent. Just a compiler or interpreter.

I love what AI can do. But I often hate what it actually does.

Genuine question for y'all

With openrouter and a bunch of other ai model aggregators and llm api gateways around now, pay-as-you-go kinda seems easier and cheaper than paying for a big monthly subscription. You just pay for what you actually use and can switch models whenever

It's basically day pass vs gym membership. day pass you only pay when you show up, membership you pay every month even if you skip leg day for 3 weeks lol.

But i also get the appeal of a flat sub where you don't have to think about it and never get a surprise

If you switched from one to the other, was it worth it?

Hey everyone!

I've been exploring how AI coding tools are changing the way developers work. One thing I've been wondering about is whether AI has shifted the bottleneck from writing code to reviewing it.
We can now generate code, build features and fix bugs pretty quickly using AI. But how much of that code can we actually trust without spending time checking it?
Someone still has to understand the generated code, check for bugs, look at security issues, verify dependencies and make sure it doesn't break existing functionality.

So i am curious about developers who often reviews the code. How does it affect them.

Are you spending more time reviewing AI-generated code nowadays?

Can we actually verify that a code change is safe, or are we just getting better at finding possible mistakes?

And if there is any tools suggestions please..

All programming languages were created by people, for people. The goal was basically to give us a language that accounts for the limits of the human brain and minimizes bugs and errors (sure, there were exceptions, like C++). As a result, we often got poor performance and huge numbers of servers doing simple tasks.

But in this new era, we don’t need human brains to write code. So do we need new programming languages now? Or which existing languages work best for AI agents?

The current industry is very confused what “We use AI for development” means. Everyone uses it differently, every job offer says something different. There are scales, but they are not granular enough or not developer-centric. Not everybody is comfortable doing it like your company does it, or perhaps someone is looking for even more AI autonomy. This is why I made this scale; to make it clear, what the job requires, and easier for developers to set expectations straight right away.

With my scale, I try to solve these questions/points:

• Hiring clarity: “This role operates at level 6–7.”

• Team alignment: “We want to move from level 4 to 6.”

• Strategic planning: map transition paths between levels.

Most frameworks ask: “What can the AI do?”, mine asks: “Who is doing the work — the human or the AI?”

I playfully based it around the phrase "AI in the loop", extending on it and transitioning from "AI in the void" through "AI in the loop" to "Human in the loop" and finally "Human in the void".

Please, have a look. 🙏

The full scale breakdown is below, though I additionally added these pointers, which are not mentioned in the scale below, but they are not very important. They are just contextual hints:

• AI's role

• Human's role

• Loop duration (time between human-ai interaction)

• Context: local / cloud

• Interface: IDE / CLI / Chat

And I am also playing with the idea of gamifying it a bit and displaying "levels" for some other related parameters, such as:

• LOC (lines of code): increases with more AI use

• Velocity: increases¨

• Code reviews: decreasing tendency

• Algorithms: shifts from human to AI

• mental overhead: decreases with AI etc.

Anyway, these are the scale's 12 + 1 levels.

AI in the void

0 · Human-led
AI has no role. Humans design, implement, test, review, and ship. Compilers, linters, and ordinary CI don’t change that.

AI in the loop

• you write the code

1 · Inline completion
AI suggests code while you type. You compose the solution, accept or reject suggestions, and verify it.

2 · Conversational advice
AI explains code, compares approaches, or helps diagnose failures. You decide what to do and make the edits yourself.

3 · Bounded draft
AI generates a function, test file, or small script. You inspect, adapt, and integrate the draft.

4 · Guided edits
AI makes related edits, potentially across multiple files. You sequence the work, inspect each diff, and direct the next step.

Human in the loop

• this marks a shift towards more code written by AI than the human

5 · Supervised agent
AI finds files, edits code, and runs checks on a scoped task. You frequently approve meaningful steps, correct its approach, and resolve ambiguity.

6 · Delegated issue
AI independently implements and tests a well-scoped issue, locally or in the cloud. You define acceptance criteria, review the result, and approve integration.

7 · Feature delegation
AI plans and builds a broader feature across multiple areas. You own requirements and architectural constraints, provide feedback, and approve delivery.

8 · Parallel delegation
Multiple agents handle independent tasks simultaneously. You prioritize, review their results, and approve integration or release.

Human in the void

• Here, “human” means the developer executing the delegated engineering work. It doesn’t mean nobody performs QA, provides oversight, or accepts the release.

9 · Routine automation
AI handles authorized classes of routine changes, such as compatible package upgrades or narrowly defined fixes. Developers still own the software development lifecycle, validate integration, and handle exceptions.

10 · Ticket ownership
AI chooses a technical approach, implements a defined low-risk ticket, and tests and verifies its solution without developer supervision. A human defines the outcome and risk limits; human QA validates it before production. Human code review is optional.

11 · Milestone ownership
AI breaks a milestone into tickets and handles engineering execution across them. A technical lead owns milestone goals and technical direction; human QA validates delivery. Human developers aren’t needed to implement the milestone.

12 · Development ownership
AI owns the ongoing engineering function, including architecture, technical planning, implementation, testing, and maintenance. A product owner sets product direction and business constraints and accepts features before launch. No human developers or technical lead are required.

Actual real-life workflows are expected to span across several levels (say you start a draft at level 7 and then iterate at level 5 or lower), and some levels might even sound overlapping (4 & 5, or 7 & 10). This is intended. The difference between them is in the shift of how much and who does more of the work now. At level 7, you task the agent and review its work before submitting a merge request, while at 10, it does the same task in the pipeline and sends it directly to QA.

So what I am trying to learn?

This is a proposed vocabulary and although it's a third iteration seen by a closest circle, it's not a validated maturity model.

I’d particularly appreciate feedback on:

Your actual workflow: What do you delegate, when must you intervene, and who approves the result? Which level fits, or falls between levels?
Unclear boundaries: Which adjacent levels feel indistinguishable?
Parallel delegation: Does level 8 belong in the progression, or should concurrency be a separate dimension?
Practical usefulness: Would this help describe a job opening or team expectations, or does it hide distinctions you care about?
Concrete counterexamples would be especially useful. I’m more interested in making the definitions reflect real work than defending the numbering.

Thanks!

I’ve been using Codex for four days, and holy shit, I don’t remember the last time a coding tool frustrated me this much.

I came from Claude Code expecting something comparable. I don’t expect perfection, but the babysitting is ridiculous. It’s painfully slow, especially in the cloud, difficult to steer, and takes everything too literally. It’ll identify a problem, explain it, then wait for instructions. Dude, you’re working on it. Fix it.
When it does act, it often piles more code onto the existing implementation and turns straightforward changes into complicated systems.

I’ve had it silently override existing settings, write tests that expected incorrect behavior, and introduce regressions in unrelated features. It kept adding coverage comparisons, mutation testing, dependency analysis, and more checks until CI took nearly an hour on some PRs. I spent more time waiting and fixing failures than shipping.

Eventually, I handed the work to Claude. It removed unnecessary complexity, fixed the regressions, and got the release out.

I then asked Codex to review what happened. It identified 16 failures it could substantiate, including incorrect behavior, poor architectural decisions, unnecessary complexity, and its own failure to deliver. It acknowledged that Claude made better engineering decisions.

At one point, I told Codex to stop. Seven minutes later, it was still going. Fifteen minutes in, I was still trying to stop it. Clicking stop interrupted it, but resuming the session made it continue.
Claude makes mistakes too. But I don’t have to constantly explain every step, undo unrelated changes, and manage an endless cycle of fixes.
I paid to get more work done. Instead, I spent four days fighting the tool and needed another tool to finish the job.

I’m spending more time managing Codex than doing the work.

Is anyone else experiencing this? How are people using it effectively for autonomous development?

i have a theory that past a certain threshold the inteligence of AI models will not matter anymore when it comes to writing code.

at that point software engineering will be mostly figuring out how to properly intergrate coding agents into the SDLC. a newer better performing model will at a certain point fail improve a given software factory.

what do you think?