I decided gaming would be my relaxation mechanism when I wrote How I Use Execution-Heavy Games for Active Recovery. This was a conscious decision, not a natural behavior. The problem became obvious quickly: playing games felt like another obligation. Sessions started with the explicit goal of "relaxing," which created performance pressure around an activity meant to eliminate pressure. Each session became evaluation of whether sufficient relaxation had occurred.
This was backward. Recovery activities that require forcing are not recovery activities.
The Forcing Problem
The pattern was consistent:
- Decide gaming session should happen
- Select game based on what "should" be relaxing
- Play while monitoring internal state for signs of relaxation
- End session feeling like a task had been completed rather than enjoying the activity
This created a second job. Work was the first job. Forcing relaxation became the second job. Downtime became obligation instead of recovery.
The core issue was legibility. Gaming produced no visible output, no skill development, no artifact. Time spent gaming registered as time without progress, which created low-grade anxiety that prevented actual recovery.
Discovery of Gittype
I found gittype while experimenting with typing games and looking for games that let you type through code. The concept was simple: type through source code character by character while reading it.
This solved the forcing problem immediately.
Typing through code felt productive because it generated a visible outcome: improved familiarity with real codebases and better pattern recognition. But it required no decision-making, no problem-solving, no sustained context. Just motor execution following existing structure.
The activity was therapeutic in a way gaming wasn't. Each line typed was completion of a discrete unit. Progress was visible and continuous. The cognitive load was minimal but non-zero, maintaining engagement without creating fatigue.
Most importantly, there was no forcing. Sessions happened naturally because the activity itself was satisfying.
Why It Worked
Several factors made this effective:
Visible output: Each session produced measurable progress through actual codebases. This satisfied the need for legible time use without creating performance pressure.
Procedural focus: The activity was pure motor execution. No strategic decisions, no planning, no ambiguity. Just type what appears on screen.
Natural boundaries: Each file or function is a discrete unit. Sessions end naturally when a logical stopping point is reached, not when arbitrary time limits expire.
Skill transfer: Better pattern recognition and typing precision transferred directly to work. The activity was both recovery and maintenance.
No forcing required: The meditative quality of typing through structured code made sessions intrinsically satisfying rather than obligatory.
The Gap That Remained
After a few weeks with gittype, a related need became apparent. Security work requires fluency with CLI tools. Reading documentation builds conceptual understanding but not motor memory.
I needed the same kind of procedural practice for security commands that gittype provided for code. Typing flags and switches repeatedly until they became automatic, with realistic context about expected output.
No equivalent tool existed. The options were either reading documentation (passive, no motor practice) or using the actual tools (requires VM setup, context switching, and doesn't isolate the syntax learning from the operational complexity).
Building Typesec
I built typesec to fill this gap. The structure was deliberately similar to gittype: type commands character by character; except with simulated outputs, and then you repeat until syntax becomes automatic.
The implementation took a few hours. I started using it immediately and have maintained consistent practice since.
The same factors that made gittype effective applied here:
- Visible progress through completed command drills
- Pure motor execution without strategic complexity
- Natural session boundaries after each deck
- Direct skill transfer to actual security work
- Intrinsically satisfying without requiring forced engagement
For more information, refer to Typesec: Building Muscle Memory For Security CLI Tools.
What Changed
The pattern shifted without conscious intervention. When I have downtime now, I open gittype or typesec and type until I reach a natural stopping point. No schedule, no forcing, no evaluation. The activity happens because it's fun and relaxing.
The difference is legibility of time use. Gaming produced no visible output and required justification. Typing through code or security commands produces measurable skill improvement while providing the same meditative motor focus.
This eliminated the forcing problem. Sessions happen because the activity is satisfying, not because a recovery protocol demands them.
Why Gaming Failed as Recovery
The issue was not gaming itself but the framing. When gaming is positioned as "recovery from work," it inherits work's evaluation structure. Sessions are assessed for effectiveness, progress is monitored, and the activity becomes another obligation.
Typing through code worked because it was never framed as recovery. It was practice that happened to be restorative as a side effect of its procedural nature.
Activities explicitly designated as recovery create pressure to recover, which prevents recovery. Activities that are naturally restorative but not framed that way function without this pressure.
Current State
Downtime now includes regular sessions with gittype and typesec. No scheduling, no forced engagement, no evaluation of relaxation effectiveness. The activities happen because they're fun and relaxing.
Work performance has improved as a side effect. Pattern recognition in code is faster. Security tool syntax is automatic. Typing precision is higher across all contexts.
Most importantly, downtime no longer feels like obligation. The forcing problem is resolved.
Standard
Recovery activities should not require forcing. If an activity needs to be scheduled and monitored for effectiveness, it is not recovery, it is another obligation.
The solution was not better gaming selection or improved willpower. It was finding activities with structural properties that made them naturally restorative without requiring explicit framing as recovery.
Gittype and typesec work because they produce visible skill development through procedural practice. This satisfies the need for legible time use while maintaining the meditative focus that enables actual recovery.
Downtime is no longer obligation. It is practice that happens to be fun and relaxing.
This is the resolution.