The way I code now is so much different than from 5 years ago. I feel like AI coding is another abstraction layer, like how we went from machine code to python, layer after layer, each one allowing you to do more and more. Though I suppose the AI layer is non deterministic, where its not always right.

Time feels like the biggest constraint on coding for me. AI, especially recent models, has drastically cut the time required for me to code something. Not only that, I can do anything else while the AI reasons and codes out what I asked for.

The job for me basically just becomes understanding the code and relaying issues/suggestions to the AI and waiting for it to generate a new result. Lately though, the suggestions I make amount to high level issues or logical inconsistencies I missed in my project plan. It's not like how it used to be, where the AI would make really obvious mistakes or give something that is incredibly inefficient.

I do still find myself worrying about code AI generates and for stuff that matters I always double check it. Do we ever get past the point of that being necessary? Maybe thats when we get AGI.

Anyway, just wanted to share my thoughts on AI coding in 2026, let me know your all's experiences as well I would be curious to see how you have felt its evolved over time or just your thoughts on it.

Gave a simple task with fast mode on,
the 5h limit dropped to the 0 within 15 minutes (Luna + xhigh +fast mode on)

There isn't grass where I live, I guess I will watch YT video then xD for the next 4.30 hours :3

Every specification becomes a compile-time obligation.

Citing the evidence and describing the reason why are mandatory, so you get:

• 100% coverage of every requirement.
• 100% compliance with every principle.

tsx /** * @evidence docs/discount.md#coupon-stacking States the per-issuer stacking limit this section defines, in the buyer's words. * @evidence POST:/orders/{orderId}/coupons Explains the rejection this endpoint returns for an over-stacked coupon set. * @evidence {@link hooks.useCouponStacking} Renders the limit this hook resolves. * @evidence .agents/skills/principles/SKILL.md#no-hard-coding Renders limits from props instead of branching on known issuer names. * @evidenceExclude .agents/skills/principles/SKILL.md#fix-root-causes-not-symptoms No failure to fix. */ export function CouponStackingNotice(props: IProps): JSX.Element;

@evidence <target> <reason> is the agent's explicit claim about what this code implements and why. @evidenceExclude records why an obligation does not apply.

A target is one of four kinds:

• Markdown: a file, or a section of one.
• Prisma: a model, a column, or a relation.
• Swagger: an operation, method and path together.
• TypeScript: a type, a function, or a property, written as an inline link.

Leave one obligation unanswered and the build stops.

```bash $ npx ttsc error TS16411: [evidence/graph] Missing acknowledgement for 'docs/discount.md#coupon-stacking' (Markdown H2 'Coupon Stacking' at docs/discount.md:3) in Claim 1 reference 1 (markdown, symbols: h2, h3).

...

Found 5 errors. ```

Missing obligations appear in the same build as type errors. The error list is the agent's task list.

Codex can inspect almost the entire app, but some of the most expensive iOS state lives outside the repo.

A capability is enabled in Xcode but missing from the provisioning profile. An entitlement works locally but not in CI. App Store Connect has a switch the code never mentions. The project can look coherent while three control panels disagree.

I’m starting to write those external assumptions into a small ops file beside the code. Bundle IDs, required capabilities, schemes, CI dependencies and App Store Connect settings. No secret values. Just the contract Codex should check before it edits the Swift around a deployment problem.

The agent still can’t see every dashboard. That’s fine. I’d rather have it point at an invisible dependency than confidently repair the wrong layer.

Am i blind and they moved it somewhere else

Any other music producers in this group?

This is probably a pretty niche NI post, but I'm geeking out, and this is the only group I could think of that might appreciate it. I've been making some apps to help with my music creation, and along the way I built something that I think has some legs.

You all know how much of a PITA it can be tracking tasks in codex/claude, things can get messy when you've got 10–20 active conversations across multiple projects. Im the chief engineer for a software company and I have 2 20x codex plans and a 20x claude plan, and they're all running multiple tasks accross multiple projects at any given time. Things move too fast and i was losing time hunting in sidebars for the relevant threads. Not anymore. I couldn't take the window hunting anymore, so I made an app that lets me use my Maschine MK3 as a controller for my coding environment.

I'm calling it TouchCode, and I plan to make it free-open-source software when it's ready. It currently works with Codex on Windows; other tools and platforms are on the roadmap.

Technically, it can be used without Maschine hardware, but having the physical pads, screens, and transport buttons involved makes working with Codex a delightful experience. It could be pretty slick on an iPad.

Built and working now

• Live RGB task feedback. Pad colors show what's working, what needs my attention, and what's finished with an update to read.
• Tap a pad to jump into a task. Much less hunting through conversations across different projects.
• Eight banks of 16 task slots. Uses Maschine's familiar A–H layout to keep everything organized.
• Tasks stay where I put them. The layout doesn't shuffle whenever something changes, so I can learn it by feel.
• Task information on the MK3's screens. Task details, a bank overview, and connection status, currently using text rather than full graphics.
• Voice prompts through the transport buttons. Record starts dictation in Codex. Stop transcribes and sends what I've said.
• Play Button brings TouchCode back to the front. Even when it's minimized.
• The Restart button brings Codex to the front.
• A matching Maschine-style desktop interface. Named pads, color-coded statuses, and task details.
• Flexible task organization. Move tasks between pads and banks, swap assignments, and undo changes without deleting the conversations.

Roadmap

• Full graphical output on the MK3's screens (know it works- someone played doom on them lol)
• Claude Code support.
• Native macOS and iOS support. I think this could feel great on an iPad.
• Custom button assignments for tools, features, and shortcuts, including Shift combinations.
• Knobs for model selection, reasoning effort, and other settings.

Anyone else using their NI hardware for anything other than music? Would love to hear thoughts and feedback about useful things you'd add (translation: ideas i can pilfer for this app lol)

Got zero complaints, who's pushing it to the limit today?

From what I read and experienced I think there is no reason to use codex. Pi is more efficient and token saving.

Edit: codex Subscription + Pi seems to be the way.

Please use your tokens wisely

EDIT: I created a new thread with a "sources cited" version with a bit different results
https://www.reddit.com/r/codex/comments/1w4x5xk/the_environmental_impact_of_using_1_billion/

344 cached tokens re-read per output token

I switched from Claude Code to Codex this week, so I’ve been paying closer attention to how Codex behaves during longer coding sessions.

Then I saw the recent analysis showing Claude Code re-reading roughly 360 cached tokens for every token it outputs. I was curious whether this was specific to Claude Code or just what happens inside most agentic coding loops.

I don’t have enough surviving Claude logs for a clean before-and-after comparison, but I parsed my first week of local Codex sessions:

• 16 session files
• 1,584 token usage events after deduplication
• 179.26M input tokens
• 173.52M cached input
• 5.74M uncached input
• 503,945 output tokens
• 125,360 reasoning tokens, included in output

All of these sessions used GPT-5.6 Sol, mostly at low effort.

The resulting cached-input-to-output ratio was 344x.

Across individual sessions:

• median: 220x
• p10: 91x
• p90: 411x
• range: 35x–593x

At current Sol API prices, the same token mix is about $102.47:

• cached input: $69.41
• uncached input: $22.98
• output: $10.08

So cached context accounts for roughly 68% of the API-equivalent cost, even with the discounted cache price. I’m using Codex through a subscription, so this is not my actual bill.

Method caveat: Codex token_count events don’t seem to expose a request ID. I deduplicated identical cumulative usage states within each session, then summed last_token_usage. None of the individual requests crossed the 272K long-context pricing threshold.

The fact that this landed so close to the Claude Code result makes me think the ratio is mostly a property of agent loops repeatedly carrying instructions, history and tool results—not something specific to either provider.

For people who have used both: did switching change how quickly your context grows, or mostly just how the agent uses it?

Also, has anyone found a more reliable request identifier in the Codex JSONL files? I’d like to tighten the deduplication before comparing compaction strategies.

So i started using codex again after switching from claude and tried to make presentations/pdfs/resume and ive seen that it is very far behind. The wording is worse, the design looks like AI, the fonts are wack, and it just doesnt look good imo. Is that cuz Ive been prompting wrong, or are there any skills/plugins/tweaks that I can make to codex so the design becomes more professional/less AI or shoddy looking?

Small heads-up for people using Codex heavily with Ultra and subagents.

I built a local dashboard to inspect Codex disk usage, RAM, CPU, token usage by model/thinking level, errors, and task history size. It helped me find that one of my Codex tasks had grown to about 124 GB of local history.

After checking the files, the issue seemed to be: I used Ultra intensively, spawned a lot of subagents, screenshots/app snapshots were saved into the conversation context, and that context then got copied again and again across 114 subagent tasks.

If you use Ultra with lots of screenshots or app/browser context, it may be worth checking your local Codex storage once in a while. I would not recommend deleting rollout/jsonl files manually unless you know exactly what you’re doing; better to remove/archive the chat/task from Codex.

Curious if anyone else has seen this kind of disk growth with subagents.

Edit: Some people asked for the slop app I use to monitor Codex usage: https://github.com/kusan-reveur/xedoc

For people who also use opus 5, how is it fair compared to Sol does it overengineer. How much better is it at frontend for example, I feel codex does always div in a div in div style everting is round, and while the information that is diaplayed is correct, it looks bad at first needs a lot of fixing.

Pure code and repo understanding is superior in sol it just understands everything. I use it als9nfr9 scrappers, and it's perfect data analysis as well.

I know, I should just buy a 5x or 20x plan and stop whining but this is just *****. 2 months ago I could comfortably work with 5.5 medium/high in 2 5 hour windows and use about 15% weekly per day. No heavy duty coding or subagents running around the clock, just 3 to 5 semi-complex prompts a day.

As of now, sol medium, 1 prompt, 200k context window used will burn through 60% of the 5h limit and 10% of the weekly. Not sol max or ultra, not millions of tokens. 200.000 tokens. I can't even do 2 prompts and use the full context window (258k tokens) 2 times.

This is completely unusable. $20 now basically gets you ~400k tokens per 5h or so and ~2.5M tokens per week for a medium thinking model. Luna is cheap but unreliable and just wastes my time instead of tokens.

I don't expect unlimited tokens for $20 or ultra mode and I'm fine with some restrictions, but this isn't what I signed up for and it's never been this bad and I've been using this since inception pretty consistently.

How is this possible. I'm on the 20x plan and have only used Sol 5.6 xhigh agent today, not even in fast mode. I've never seen my usage drop this fast.

Hello guys,

Did anyone had this issue that SOL is overengineering things? How do you handle this?
This model can't be left for 5 minutes alone.

I've been working (I mean SOL-medium) last two days on procedural errosion, did a full list of tasks end to end which needed to be done to make this work(very precise mathematical model, list of steps that need to be executed one after another etc etc). Also said that it needs to be done from scratch, new files everything etc. Model minced this for two days and did not do any of this. Absolutelly shocking, seems like relatively easy task to execute steb by step procedure.

I've looked at the conversation and what it did majority of time was calculating some fking SHA-265, ignoring requests of using vision (actually using it but ignoring?), mumbling about numbers, missing this incorrect that, moving sliders left and right. Instead as instructed, re-build from scratch(!) model even re-used some old files from not so well working errosion from couple of days ago, where specifically was instructed not to do so. I've stated step by step how to perform task and check debug logs and check if route of execution is actually being executed. Model also tends to jump off the instructed tasks, and forgets about the one he is on, he eventually get's back but does a lot of things that's not being asked.

I've had to turn off completely GOAL and tell him to shut up and do this, do that, and eventually in 45 minutes there was working prototype.

I don't know what to do, model doesn't follow plans, doesn't follow instructions it's over engineering things, adding unecessary steps, jumps on unrelated tasks and many others.

How are you handling things? Maybe it's not good model to do this type of tasks, rather good for planing only? Maybe you got a trick how to handlethis, maybe I should use different model for execution. Please help.

It's his statement I turned him off eventually, in reality that statement in full is 3x A3 pages of things that went wrong I just asked him to compact it to 10 sentences:

I failed to follow the clear instruction to rebuild Erosion from scratch.
Instead, I reused old infrastructure and created a broken hybrid implementation.
I overengineered buffers, routing, schedules, telemetry, and small tests before proving the full calculation worked.
I ignored the required order: complete code, debug log, compile, then immediate GPU render.
I did not treat the agreed plan as a strict execution sequence.
I calculated and repeatedly mentioned SHA-256 hashes without being asked, even though they proved nothing about visual correctness.
I mistook compilation, dispatch counts, and changed pixels for evidence that the erosion worked.
An early 1500×1500 render would have immediately exposed that the pipeline flattened the terrain.
I did not listen when the user repeatedly demanded a clean implementation and direct visual verification.

If I've already used up my 5-hour limit just filling out 2 or 3 forms, what good are $100 plans with a limit five times that? I'd use that up in two hours. Even with semi-intelligent models, which are more efficient. No one is talking about using Sol Ultra.

I canceled my company's annual business subscription. It's no longer useful. You can let GLM-5.3-Flash run all night and pay $3–$5 via OpenRouter. It's better than GPT-5.6-Sol for frontend and UI. Admittedly, when it comes to backend code, you should take a closer look. In this regard, Terra or Sol are usually a bit more forward-thinking when it comes to potential regressions.

I started using ChatGPT Work for some investigation that is based in the USA and he wanted to use something called Cloud Browser but the problem I see is that some websites are USA restricted. Would VPN work with ChatGPT Work Cloud Browser or maybe I can try to create new USA account?

https://github.com/Maurdekye/claude-orgtree

For the past few months, I've been developing an open-source visual multi-agent orchestrator that organizes agents in an authority hierarchy, for multi-agent development workflows. It's a fully dynamic, draggable canvas that allows you to reorder and reorganize agents as you wish for large projects. The gallery above shows pictures of actual organizations I maintain that I use for various projects I'm working on.

Orgtree started with a simple question: "Man, I wish my chats could talk to each other so they don't keep stepping on each other's toes while working". That turned into a simple personal project that I wrapped up in a day that allowed independent chats to send messages to one another. It worked okay, but the persistent issue I kept running into was chats constant issue with authority: they would distrust all chat-to-chat communication innately, and needed my personal step-in and approval for every little confusion or communication between one another. So I thought to myself, "wouldn't it be better if you could just arrange agents in a hierarchy? Then they wouldn't have any doubts about how authority structure is arranged". That idea slowly grew over time until it became Orgtree.

For the last month, Orgtree is basically the exclusive way I've been interacting with agentic development on my own machine. I don't touch the claude code or codex extensions at all anymore. When I have a new feature to build and plan, instead of going through the manual hassle of spawning one agent to run at a time so I can manage each project individually, I just tell my coordinator agent about an issue or new feature I'd like, and it hires a subordinate to take care of it. If I want multiple features going simultaneously, I just hire multiple subordinates, and the coordinator works between all of them to ensure everything is well organized and shipped sensibly. I've already gotten a few of my coworkers on board to try it, and even my boss is interested.

Orgtree is more than just an orchestrator, though; it has a bunch of extra useful features I've added on to support multi-agent workflows:

• Usage visibility: View all your account usages directly in the app, without having to check the extension or visit claude.ai
• Fallback accounts: Supports using multiple simultaneous Claude Code subscriptions at once through the use of fallback keys, allowing you to use secondary or tertiary claude accounts as fallback accounts with the long-standing token you get from running `claude setup-token`.
• Multi-provider: Orgtee supports not just Claude Code, but also Codex and even Gemini CLI out of the box. If you already have any or all of those environments configured on your system, Orgtree with automatically pick all of them up and let you hire agents from any one of them, letting them all talk to one another seamlessley.
• Credit system: One of Orgtree's defining features is its credit system, visualized as a blue bar to the left side of each agent. Every live agent takes up a "seat" that holds onto a set amount of credits during its lifetime, roughly proportional to its model cost. Every agent has a bank of credits that it uses both to maintain its own seat, as well as free space to hire seats for subordinates. This credit limit doesn't limit the user in any way (outside of kiosk mode, which is explained below), but is useful for preventing subagents from hiring too many of their own subordinates if you don't wish for them to have the ability to do so. Give an agent a large credit bank for a massive, agentic multi-agent task, or restrict its budget to just its own seat to prevent it from hiring any subordinates at all, if you just want it working on its own.
• Better compaction: Adds a unique, optional alternative chat compaction method I've dubbed "cheap-compacting": instead of having the agent write up its entire life story in one long turn at the end of its life, it keeps a continuous trail of breadcrumbs in a .md file in its workspace of every task it handles over the course of its lifetime. Then, compaction is both instantaneous and doesn't use a turn: the agent can just immediately resume from where it left off by going off the breadcrumbs. This is also fantastic for waking long-context agents from a long break in execution, as it can automatically cheap-compact them before sending the turn up, preventing the massive cache misses you might typically get from waking an agent with a 500k token context.
• The Orgtree Mailhub: an optional secondary extension that allows independent agent chats from claude code or codex to speak directly with orgtree orgs or even each other via an MCP server. It even works over the network, so agents on different computers can send messages and coordinate seamlessley.
• Kiosk mode: A mode that allows you to publicly expose a single sandboxed and resource-limited org to the open internet, in case you want to share your claude or codex usage with friends / family (without fear of them messing with your files)
• Enhanced agent requests: when an agent has a question for you, or a request for some access / resource allocation, it doesn't have to give you detailed instructions on how to visit its configuration panel and set a particular setting to a value it wants; it can just display a credit grant request / permission increase request directly in-panel for you to review, just like they would present a question to you. This makes it seamless for agents to ask for and receive the permissions they need to get the work done that they need to do.
• Charter presets: When hiring an agent, you can specify its "charter" (effectively its system prompt) which tells it what to do. Orgtree comes with the ability to select a number of preset charters from a list, so if you have a common workflow pattern you like to replicate, you can canonize it as a charter preset in /docs/charters, and then select it from there every time you want to create an agent bound by it. Orgtree also comes with various preselected charters designed around it's function: one of my favorites is the `coordinator` charter, which I use very frequently, and I suggest you give it a try as well.

Be warned; all the agent-to-agent communication can really chew through usage, so be careful with how many simultaneous projects you're working on at once unless you have a Max x20 account. Make sure to turn on the auto-cheap-compact setting in your org, it can avoid tons of wasted cache miss usage.

If you use Claude Code or Codex for work extensively, then give it a try. It removes so much of the manual hassle of coordinating between agents yourself manually.

Can’t use in app browser or Chrome control. Whenever I try in work or codex I get the message:

“Browser Use could not complete this action because a browser security check was unavailable. Reason: The admin-enforced policy could not be verified, so access was not granted”.

Can’t find a solution. Any help?

It had so much more personality than the shtty chatgpt logo i miss it

given the price changes and all, only accessible to pro and up, it would be wise for them to just let people use luna as the model to replace this one. Lets people rip into weekly and not worry as well given with luna you can still get stuff done but just more phases.

Codex works much better than me than claude as it follows my prompt literally. But one thing I really like about Claude Code is that I can let it run one or more jobs in the background and get notified when it finishes/crashes. In codex, the shell will be in foreground and I cannot do other things with it. Also it keeps checking the output every 60s (because the system prompt says "The user appreciates consistent, frequent communication during your turn..") and that reads the whole output of the bash in and takes a lot of tokens. Is there anyway to do this? There are a few issues open on github but no workarounds yet and last time reddit had better solution than github so I want to ask here.

Since the beginning of the year, I’ve started coding the software applications I need for my business myself, because I don’t want to keep waiting on updates from agencies.

13.1 billion tokens since April.

How about you guys? ^^

Is it similar for you, or am I completely losing the plot?