Am I Doing It Right?

I was listening to a podcast earlier this week with a guest for which I had a good chunk of respect. The host and this guest talked about how they utilized AI, the shift in model capabilities at the end of 2025, and how much code they actually wrote by hand.

At first the experiences mirrored mine pretty closely. I too had noticed the shift in model capability in 2025, and had adjusted my workflow accordingly. Unless it was to learn a new concept or working on my simulation game, I hadn’t written much code “by hand” since that time. I was using specifications to help drive my development, and was spending a considerable amount of time exploring the context needed by agents prior to implementation. Pretty soon though, my experiences started to differ from the guest.

They talked about having multiple agents working in parallel on multiple features. They often ran large orchestration patterns, leaving things to work without their oversight for hours or overnight. They typically used the frontier lab models, and all flavors of Opus/Fable etc. What really shocked me is that the guest started talking about the amount of money he was spending.

Even on subsidized subscriptions he was spending thousands in tokens monthly. They had a whole section of the podcast talking about token economics and trying to keep them low enough not to have to hire junior developers (which I find problematic but that’s a topic for another blog post). I was incredibly shocked. I knew people spent that much on tokens, but I didn’t expect such a heavy spend out of someone I felt was very skilled and prolific in their code.

The revelation on how much they were spending was shocking because I’ve never spent more than $150 USD monthly in tokens, ever. I use OpenRouter exclusively for personal projects and pay by usage, no subscription. My current personal usage this month (time of writing September 18th 2026) sits at $23.50 USD. At work we have metered usage as well, with budgets enforced at the organization level. There, where the bulk of my programming takes place, I’ve spent $26.75 USD - both with about a billion tokens used. I am extremely productive both at home and at work, typically doing a solid 1-2 features a day before QA. On my personal projects, if I’m not careful, I get hyper-focused and churn out even more than that.

Up until this point talk about token cost and economics were something I thought of discussing only at the macro level - about organizations who provided tokens to engineers and the like. I started to dig deeper and I started asking myself this question daily:

Am I doing it right?

I started talking to my colleagues about their usage after listening to that podcast, and was surprised by the fact that almost every engineer producing code on my team was hitting their daily limit every day. My monthly usage was a fraction of their daily usage and I was producing just as much code, pull requests, and completed features as they were.

I also explored their workflows more often and more in-depth. I wanted to find out why my usage was so much lower and what I was doing differently. Honestly, I was a bit self-conscious about my use and worried that I was missing something obvious that everyone else had picked up on right away.

I’ve highlighted a few of the major differences I found over the last month. Please bear in mind that my sample size is small and ranges from junior to senior engineers on both frontend, backend, and infrastructure tasks. I also have a purely nontechnical founder thrown in there for good measure.

Difference #1 - Harness and Setup

I use Pi exclusively. I’ve played around with OpenCode, Claude Code and DeepSeek’s harness in order to familiarize myself with the playing field - but keep coming back to Pi due to its simplicity and how it fits my workflow. My setup is fairly simple: I have whatever project open in Zed or VSCode - just like it was back in the hand-crafted days. I have the internal terminal pane open and typically pulled to a third/half of the space in the main editor window. In that terminal I boot into a single instance of Pi.

My Pi itself is pretty sparse in its setup. I’ve published my settings which includes all subagent personas, prompt templates, and extensions I use. I have only ever felt the need for a single MCP server, and that was Tidewave for Elixir/Erlang projects. Every other interaction with an MCP server I let the agent typically handle on the fly, noting available MCP servers in an AGENTS.md and with instructions to only query the service if they need to perform x, y, z.

When I’ve shared my setup with colleagues who have been heavy agentic AI users I get a lot of questions about capability and usability. “What about feature x?” - half the time said feature is something standard code editors or IDEs have had for the last decade. Why would you ever use a new TUI for diffing when you have an editor you’re familiar with? Or lazygit? Why would I want my harness developers to spend time building these kinds of features instead of optimizing the harness?

There’s a big truth here for Claude Code users especially -

If your harness is owned, subsidized or managed by a model provider (e.g Claude Code), they have no reason to make that harness economical to use.

Why would Claude Code optimize for low token usage and high economics when it doesn’t benefit the labs if people are spending less? I don’t know that they’re maliciously avoiding making the harness economical to use, but it’s definitely not forefront in their priority list. Pi, for the most part, adheres to the old adage that “less is more” - and it pays dividends when my token use is the cost of a meal at a mid-grade restaurant.

Difference #2 - Workflow

The way I develop with an agent mirrors my own development patterns pretty closely.

1. I start with an objective document - a simple markdown document stating my end goal, some acceptance criteria, and any notes I feel relevant to the feature/bug/task I’m going to have the agent perform.
2. I ask the agent to read the objective document and perform the task. I let this agent run for anywhere from five to ten minutes, or until I start to see diffs on the current VCS work space. I cancel the agent at that point and review what was created. Sometimes the agent has started down a good path, in which case I’ll let it go and do its thing and do only minimal steering. This doesn’t happen every often though, so I typically go to the next step.
3. Taking what I’ve seen the agent try so far, I update my objective document and add notes about things to avoid or patterns to follow. Then I use my /clarify prompt template. This prompt has the agent building a high level SPEC.md document and using the rpiv-ask-user-question extension to work with me, clarifying any points it needs my input on.
4. I review the SPEC.md and make any changes I feel are necessary, answering any questions for the user that agent might have missed or couldn’t understand.
5. I then use the /chain-prompt feature to chain two prompt templates together - /plan and /implement. The /plan prompt builds a much lower level plan to be followed by the implementing agent in the subsequent step. Each prompt agent has the ability to utilize any number of sub-agents to accomplish its goals.

A key piece of information to note here is that between each prompt template and step I clear the context completely. I have never seen my context window expand past 25% of whatever was available (typically 1 million). I tend to build documentation into my workflows and leave notes into the repository itself, either in documentation, linting rules, or when all else fails updating AGENTS.md and praying.

Difference #3 - Model Choice

I typically only use two models, at various levels of thinking effort. Those are Deepseek V4 Flash and GPT 5.6 Luna. For reference, here are the costs on OpenRouter at time of writing:

openai/gpt-5.6-luna Input: $0.20/M Output: $1.20/M

deepseek/deepseek-v4-flash-latest Input: $0.05/M Output: $0.16/M

When I compare to my colleagues, almost all of them are using the latest model they can get a hold of. While I have used Opus and Fable, I reserve those for extremely high level, large context tasks such as auditing code, security checks, or repository mapping. I’ve found that Luna and V4 Flash hit a sweet spot in being extremely capable programming models and hitting the level of independence in line with how I program.

Conclusion

Now that you know how I work please let me know - am I doing it right? Am I missing something obvious or some workflow that will legitimately 10x me from where I’m at right now?