🤖 I’m literally sick of such arrogant AI coding advice

22 Oct, 2026

I bookmarked this r/codex Reddit thread, and I happened to reread it: Is Chatgpt Plus the better option nowadays? (for Mainly Codex)

Zeyad Karim: I am thinking about subscribing to ChatGPT Plus, but the Codex token usage problems these days make me unsure of it, since mostly what was said that it finishes tokens 3x faster and is not as smart as it used to be, so idk what to do.

I am on the ChatGPT Go plan and literally Codex finishes its monthly limit in 4-5 messages, since the Go plan doesn't have the 5-hour limit along with the weekly limit. I want to upgrade.

On the other hand Claude Pro plan seems to be a good choice here, and in my region it's 30% cheaper than ChatGPT Plus. So I don't know who's better.

I mainly use it in cybersecurity related stuff, building agents and code review... etc.

alexelcu: This message isn't necessarily for the author but for AI rookies of all kinds...

I'm getting a lot of work done with Chatgpt Plus and rarely hit the limits. The complaints usually come from people that waste tokens.

If you are a software developer, you can make an effort to direct the agent were needed. Don't let it assume too much. Yes, the agent is smart enough for one-shot implementations created from single sentence prompts, however the result will degenerate into a "big ball of mud". If it's hard to maintain for humans, it's hard to maintain for AI, which will lead to wasted tokens and frustration. Invest in good practices and maintainability, do it early and often.
Programming language matters. Use a static and expressive language. Use functional programming. For example, Typescript with Effect or Kotlin with Arrow or Rust beat Python because the agent has less room for error and a faster feedback loop due to having a compiler. But do learn that programming language. Sorry, the vibe coders don't get far when full of ignorance and for only $20.
Use OpenCode, learn to configure it, teach it how to offload the grunt work to cheaper models. Use GPT-5.4-mini for sub-agents doing the grunt work, or also get an OpenCode Go subscription ($10) and offload the grunt work to a cheap Chinese model like Deepseek. Also useful as a fallback for when you hit limits.

Configuring your harness to offload work and use the best model for the job will be a time sink at first, but it pays off. For me, the $100 subscription felt unlimited, had to make an effort to keep agents going (feeling guilty that I'm wasting time), so I eventually cancelled it, going back to the $20 one (plus opencode go, which is useful in Github actions as well, as replacement for Copilot, but that's another story).

Danoxor: Could you elaborate please on what you consider grunt work and how to teach it to offload?

alexelcu: I first started using oh-my-openagent, and then oh-my-opencode-slim. These may satisfy you, although I found them to be too bloated, especially the former — although, it's pretty cool that it models a loop that doesn't stop a task until it's done. Notice how both plugins configure multiple agents that are specialized for certain tasks.

Nowadays, I'm just using vanilla OpenCode, slowly building configuration based on needs. One of these days I might even migrate to Pi, although OpenCode has been good enough.

For example, my primary agent currently has a prompt like this (probably not perfect, but does the job for my needs):

## Sub-agents delegation

**Delegate aggressively:** use cheaper sub-agents (`explore`, `general`) for grunt work and routine tool calls.

Delegation to sub-agents is REQUIRED for...

- Compilation, typecheck, build, test, lint, and format commands
- Test failures when the intended behavior is clear
- Library API investigations
- Rename a symbol project-wide (or other superficial refactorings)
- Mechanical find-and-replace across the codebase
- Broad codebase searches or tracing across multiple files

However, you are still the primary implementer and architect. Do **not** hand off the entire request to a subagent and wait passively for results. Delegation is for well-scoped tasks where the objective and success criteria are clear *before* you delegate; you remain responsible for integrating findings, deciding the approach, and performing the meaningful edits yourself.

**Command/fix loops:** Delegate verification commands and clear failures to **general**; let it run, fix, and repeat until green. Step in only for architectural judgment.

**REQUIREMENT:** Delegated tasks must be small and manageable enough that you stay in control. Never delegate decision-making, design trade-offs, or the overall orchestration of the request.

## Constraints

- Respect `AGENTS.md` (the rule of law!).
- Follow existing code style and patterns.
- Update tests when changing behavior.
- Practice TDD (write tests and see them fail _before_ implementing changes that turns them green).
- Flag uncertainty rather than guessing.

And then in opencode.json you could have a model configuration like this:

"agent": {
    "plan": {
      "model": "openai/gpt-5.5",
      "variant": "high"
    },
    "build": {
      "model": "openai/gpt-5.5",
      "variant": "high"
    },
    "general": {
      "model": "openai/gpt-5.4-mini",
      "variant": "medium"
    },
    "explore": {
      "model": "openai/gpt-5.4-mini",
      "variant": "medium"
    }
  }

See the docs. It's not much to do, but you'll probably need to trial & error. Building plugins for custom behavior is very doable too, especially as the AI can find out how.

The rest is not important. alexelcu is the one who seems arrogant. “Use functional programming.” “Typescript with Effect or Kotlin with Arrow or Rust.” Y tu mamá también.