I don’t want to turn this into a productivity flex.
This is a retrospective on attention and systems, and on how the Operator mindset emerged for me before it had a name.
The primary artifact for this story is not a journal entry or a carefully curated narrative.
It’s my GitHub activity.
The Problem
GitHub is not truth, but it is a decent proxy for where your attention went. It records what you touched, how often you changed your mind, and how many times you had to go back and “just fix one more thing.”
My raw numbers this year look like this:
- roughly 3,300 GitHub commits
- only three intentional no-commit days (Dec 24 - 26)
- a baseline of a few commits a day, and much more early in the year
If you stop there, you can tell yourself a story about discipline and output.
But numbers alone are a dangerous narrator. They don’t measure clarity. They don’t measure leverage. They definitely don’t measure emotional cost.
They only show patterns worth investigating.
Q1, Q2: Founder Mode, High Output, Rising Friction
In the first half of the year, I was in founder mode: responsibility-heavy, output-oriented, and always carrying the feeling that anything I didn’t do would quietly become a future fire.
On paper, it was fine. The weeks were structured. There was even a four-day work week “on paper.”
In reality, my day was chopped into fragments:
- context switching between product, engineering, and people
- short bursts of implementation followed by short bursts of coordination
- a steady drumbeat of “ship, ship, ship”
I wasn’t burning out in the dramatic sense. I was still functional. I was still delivering.
But by late April I noticed something that mattered more than my streak:
I was starting to hate the code.
Not because the code was unusually bad, but because my relationship to it had changed. It stopped feeling like building, and started feeling like dragging a heavy object across sand.
That’s what friction feels like when it becomes constant.
The Exit (End of April / Early May)
I exited the company around the end of April / beginning of May.
It’s important to name the shape of that decision: it wasn’t a failure exit. It was an alignment exit.
I was exhausted. Not broken, but drained in a way that makes everything feel slightly heavier than it should.
May: A Month “Off” That Wasn’t Idle
I took a full month.
Not the cinematic version of rest. More like a long exhale where I let curiosity lead again: building small things, experimenting, following threads without turning them into roadmaps.
At the time it looked like “doing nothing.” In retrospect it was a reset of attention.
I didn’t just need time away from work. I needed time away from the feeling of being cornered by a backlog.
Focus Without Exhaustion
After that, I joined a startup with clear goals, minimal meeting overhead, and space to explore without paying a constant emotional tax.
The work didn’t become easier, but it became cleaner. There is a difference.
When the environment is calmer, you can allocate attention deliberately instead of reactively. That single shift changes everything downstream: architecture decisions, quality, even how you experience the day.
The AI Phase: Agentic Coding, Then Agentic Multitasking
This is where AI enters the story.
I started exploring agentic workflows and multi-threaded AI-assisted work. It felt like a superpower at first: multiple threads moving, multiple problems “being handled,” progress in parallel.
But the deeper truth was uncomfortable:
I wasn’t becoming an Operator. I was becoming an agentic multitasker.
The pattern looked like this: start three things, half-finish them, context-switch to correct outputs, prompt again, patch again, and then open the next thread because the last one felt “blocked.”
It created a particular illusion: constant motion that looked like delivery.
October: When the Graph Lied
In October, the GitHub graph spiked. Some days were absurd: 50 commits where earlier months averaged a handful.
If you only read the histogram, it looks like a breakthrough.
If you read the diffs, it often looks like thrash:
first-pass features, then bug fixes, then regressions, then prompt corrections, then cleanup commits, then “small refactor” that existed mostly to make the last patch coherent.
High activity is not high delivery.
Sometimes it is the opposite: activity as a symptom of missing clarity.
By the end of October, burnout peaked, not because I was shipping too much, but because I was paying for every feature multiple times.
The Solution (The Calm Way)
The turning point wasn’t a new model.
It was attention.
I realized the problem wasn’t AI. It wasn’t speed. It was how I was allocating my attention: too much time inside conversational loops, too much “fix it live,” too little deliberate setup.
That shift produced the first Operator rules for me:
I started thinking longer before invoking AI.
I started reducing conversational loops by front-loading constraints.
I started designing flows instead of writing prompts.
In other words: I stopped treating the model like a collaborator who needs constant steering, and started treating it like a system that performs best with clean inputs.
The Operator mindset wasn’t designed upfront. It condensed out of a year of friction.
"The system didn’t appear. It condensed."
Re-reading the Year Through GitHub
When I re-read the year through GitHub, the arc looks clearer than it felt while living it.
Early year: fewer commits, more meaning per commit.
Mid year: exploration, curiosity, a quieter pace.
October: noise. Activity without leverage.
After the Operator shift: fewer retries, calmer graphs, and a different internal feeling while working.
The data didn’t change.
The interpretation did.
Conclusion
This year wasn’t about shipping more.
It was about learning how to work without burning attention.
Operator isn’t a job title.
It’s what remains after you remove waste from how you think, how you decide, and how you run the system. t