Building Systems That Practice for You: Automation for Skill Development

I wanted to get better at writing.

My plan: “I’ll write every day.”

What happened:

Day 1: Wrote 500 words. Felt great.

Day 2: Forgot to write until 11 PM. Rushed 200 words.

Day 3: Too tired. Skipped.

Day 4: “I’ll write tomorrow.”

Day 7: Hadn’t written since Day 2.

The problem: I relied on willpower and memory.

Willpower is finite. Memory is unreliable.

Then I built a system.

The system:

1. Automatic: Calendar blocks at 8 AM every day: “WRITE.”
2. Forcing function: Text editor opens automatically at 8 AM (via script).
3. Accountability: Script posts to Twitter if I don’t write 500 words by 9 AM: “I failed to write today.”
4. Friction removal: Writing prompts pre-loaded, research done the night before.
5. Measurement: Word count automatically tracked and graphed.

The result:

I didn’t need to remember to write. The system reminded me.

I didn’t need willpower to start. The text editor was already open.

I didn’t want public failure. The accountability forced me to write.

I had no excuses. Everything was prepared.

After 90 days: 45,000 words written. Missed only 2 days.

I didn’t get more disciplined.

I built a system that practiced for me.

The Problem with Willpower-Based Practice

Traditional practice relies on:

• Remembering to do it
• Deciding to do it
• Overcoming resistance
• Maintaining consistency

Every one of these is a failure point.

Four chances to fail. One chance to succeed.

System-based practice flips this:

The system removes the decision entirely.

What is a Practice System?

A practice system is an automated or semi-automated structure that:

1. Triggers practice without conscious decision
2. Removes friction from starting
3. Enforces accountability
4. Tracks progress automatically
5. Provides feedback

The goal: Make practice the path of least resistance.

Story: The Programmer Who Automated Learning

Meet Jake.

Jake wanted to get better at algorithms.

Traditional approach:

“I’ll solve one LeetCode problem every day.”

Reality: Solved 3 problems in 2 weeks. Lost motivation.

Then Jake built systems:

System 1: The Morning Trigger

Automation:

Created a cron job that:

• At 8 AM, opens browser to a random LeetCode problem
• Blocks all other websites until problem is attempted
• Sends Slack message to accountability partner: “Jake is solving today’s problem”

Result: Can’t avoid it. Browser is already there. Partner is watching.

System 2: The Forcing Function

Automation:

Set up a GitHub Action that:

• Runs every day at 9 AM
• Checks if a solution was committed
• If no commit, posts to Twitter: “I skipped practice today”

Result: Public accountability. Don’t want to fail publicly.

System 3: The Progress Dashboard

Automation:

Built a script that:

• Tracks problems solved
• Calculates streak
• Generates difficulty distribution graph
• Shows weak areas
• Emails weekly report

Result: Visible progress. Can see improvement. Knows where to focus.

System 4: The Difficulty Ladder

Automation:

Algorithm that:

• Starts with easy problems
• Increases difficulty after 3 consecutive successes
• Drops difficulty after 2 consecutive failures
• Ensures gradual progression

Result: Always challenged, never overwhelmed.

The outcome:

Without systems: 3 problems in 2 weeks.

With systems: 180 problems in 6 months. Consistent daily practice.

Jake didn’t get more disciplined. He engineered away the need for discipline.

The Five Types of Practice Systems

Type 1: Trigger Systems

Purpose: Automatically initiate practice.

Examples:

For coding:

• Calendar blocks with automatic IDE launch
• Cron jobs that open specific projects
• Browser extension that blocks Reddit unless you’ve written code today

For writing:

• Text editor auto-opens at set time
• Phone alarm that won’t dismiss until you write 100 words
• Email reminder with today’s writing prompt

For fitness:

• Gym clothes laid out automatically (robot vacuum pushes them to bed)
• Calendar blocks for workout with location reminder
• Smart home turns on workout music at set time

The pattern: Remove the “remember to start” failure point.

Type 2: Forcing Functions

Purpose: Make NOT practicing harder than practicing.

Examples:

For learning:

• Website blocker that only unlocks after answering quiz questions
• Reddit access requires solving one coding problem first
• Twitter bot shames you publicly if you don’t practice

For writing:

• Donate $10 to a charity you hate if you miss a day (automated via Beeminder)
• Writing streak displayed publicly on your website
• Can’t access email until you’ve written your daily words

For skill practice:

• Chess app that blocks other apps until you’ve done tactics training
• Language learning app required before phone unlock
• Code review required before merging (enforced by git hooks)

The pattern: Make the path of least resistance the desired behavior.

Type 3: Feedback Systems

Purpose: Automatically measure and report progress.

Examples:

For coding:

• Test coverage displayed in IDE in real-time
• GitHub Actions run tests on every commit
• Code quality metrics tracked automatically
• Performance regression alerts

For writing:

• Word count tracker with daily goals
• Readability score calculated automatically
• Weekly reports on output and consistency
• Hemingway Editor integrated into editor

For general learning:

• Anki spaced repetition automatically schedules reviews
• Habit tracking app shows streak and statistics
• Learning journal automatically compiled from daily entries

The pattern: You don’t have to remember to measure. The system does it.

Type 4: Environment Design Systems

Purpose: Shape the environment to make practice inevitable.

Examples:

For coding:

• IDE already open to yesterday’s work
• Test file template auto-generated when creating new files
• Linter prevents commit of bad code (enforced, not suggested)
• Pair programming hours blocked on calendar

For writing:

• Distraction-free mode enabled automatically at writing time
• Phone automatically goes to Do Not Disturb
• Writing apps the only allowed programs during writing blocks
• Standing desk auto-raises at writing time

For learning:

• Study materials the only things on desk
• Phone in another room (time-locked box)
• Internet disabled except for specific learning sites
• Noise-canceling headphones auto-connect with focus music

The pattern: Environment forces the desired behavior.

Type 5: Accountability Systems

Purpose: Create social or financial consequences.

Examples:

For any practice:

• Daily check-in with accountability partner (automated reminder)
• Public dashboard showing your practice streak
• Money at stake (Beeminder, StickK)
• Community challenges with public scoreboards

For coding:

• Commit streak displayed on GitHub profile
• Daily progress posts to Twitter (automated)
• Pair programming sessions scheduled automatically
• Code review exchange with peer (both reminded automatically)

For writing:

• Blog post schedule published publicly
• Newsletter commitments with deadlines
• Writing group with required weekly submissions
• Editor expecting drafts on set schedule

The pattern: Other people create pressure to practice.

Building Your First Practice System

Here’s a step-by-step:

Step 1: Identify the Skill

Pick ONE skill to systematize.

Don’t try to build systems for everything at once.

Example: “I want to practice coding algorithms daily.”

Step 2: Map the Failure Points

Where does your current practice fail?

Common failure points:

• “I forget to practice”
• “I don’t know what to practice”
• “It’s too hard to start”
• “I lose motivation”
• “I don’t see progress”

For algorithm practice:

• ✓ I forget to practice
• ✓ I don’t know which problem to solve
• ✓ Too much friction to open LeetCode and pick a problem

Step 3: Design Automations for Each Failure Point

For each failure point, create an automation.

Failure: “I forget”

Automation: Calendar event at 8 AM with link to LeetCode

Failure: “I don’t know which problem”

Automation: Random problem selector script

Failure: “Too much friction to start”

Automation: Browser auto-opens to today’s problem

Step 4: Add Accountability

Make it harder to skip than to do.

Options:

• Social: Tweet your streak daily
• Financial: $10 to charity you hate if you skip
• Peer: Daily check-in with partner
• Public: Dashboard showing your progress

For algorithm practice:

Beeminder integration: $10 pledge if I don’t solve a problem by 9 AM.

Step 5: Add Measurement

Track automatically.

For algorithm practice:

Track:

• Problems solved per day
• Current streak
• Difficulty distribution
• Topics covered
• Success rate

Automation: Script scrapes LeetCode profile, updates spreadsheet, sends weekly summary.

Step 6: Iterate

Run the system for 2 weeks.

Ask:

• What’s still friction?
• What am I skipping?
• What could be automated?

Refine the system.

Example refinement:

“I’m solving problems but not reviewing mistakes.”

Add: Automated prompt after solving: “What did you learn? What would you do differently?”

Real-World Practice Systems I’ve Built

System 1: The Writing System

Goal: Write 500 words daily.

Automations:

1. 8 AM: Calendar block with “WRITE” notification
2. 8:01 AM: Text editor auto-opens to today’s writing file
3. 8:02 AM: Website blocker enables (only writing app accessible)
4. 9 AM: If <500 words, Beeminder charges $10
5. End of day: Word count automatically logged to spreadsheet
6. Weekly: Progress report emailed with graphs

Results:

Before: 2-3 posts per month, inconsistent

After: 500+ words daily, 90% consistency

System 2: The Code Quality System

Goal: Improve code quality without thinking about it.

Automations:

1. Git hooks: Prevent commit if:

   • Tests don’t pass
   • Coverage drops below 80%
   • Linter shows errors
   • Files exceed 300 lines

2. CI/CD: On every PR:

   • Run tests
   • Check coverage
   • Run linter
   • Check complexity metrics
   • Post report to PR

3. IDE: Real-time:

   • Show test coverage
   • Highlight code smells
   • Suggest refactorings

Results:

Before: Inconsistent code quality, bugs in production

After: Consistent quality, catch issues before PR

System 3: The Learning System

Goal: Learn something new every day.

Automations:

1. Morning: Anki automatically opens with today’s reviews
2. Can’t close Anki until reviews complete
3. Evening: Prompt: “What did you learn today?”
4. Automatically: Creates learning journal entry
5. Weekly: Compiles week’s learnings into summary
6. Monthly: Generates topic distribution and gaps

Results:

Before: Vague sense of “learning things”

After: 3650 learning entries per year, visible progress

System 4: The Health System

Goal: Exercise 5x per week.

Automations:

1. 6 AM: Smart lights gradually turn on
2. 6:10 AM: Workout music auto-plays
3. 6:15 AM: Fitness app opens with today’s workout
4. Gym clothes already laid out (evening routine)
5. Workout logged automatically by smartwatch
6. Missed workout: $20 to charity I hate (automated)

Results:

Before: 1-2 workouts per week

After: 4-5 workouts per week, consistent

The Tools for Building Practice Systems

For Trigger Automation

Calendar apps:

• Google Calendar with notifications
• Fantastical with automation rules
• Calendly for scheduling accountability

Scripts:

• Cron jobs (Mac/Linux)
• Task Scheduler (Windows)
• Keyboard Maestro (Mac automation)
• AutoHotkey (Windows automation)

Apps:

• IFTTT (If This Then That)
• Zapier (workflow automation)
• Shortcuts (iOS automation)

For Blocking/Forcing

Website blockers:

• Cold Turkey (hardcore blocking)
• Freedom (cross-device blocking)
• Focus (Mac blocking with scheduling)

Accountability:

• Beeminder (money on the line)
• StickK (commitment contracts)
• Coach.me (public tracking)

For Measurement

Tracking:

• Airtable (flexible databases)
• Notion (databases + automation)
• Google Sheets (with Apps Script)
• Obsidian (with Dataview plugin)

Habit tracking:

• Habitica (gamified)
• Streaks (iOS, visual)
• Loop Habit Tracker (Android, open source)

Analytics:

• RescueTime (automatic time tracking)
• Toggl (manual time tracking)
• WakaTime (coding time tracking)

For Environment

Focus tools:

• Freedom (internet blocking)
• Forest (phone focus with trees)
• Brain.fm (focus music)

Workspace:

• Smart lights (automated lighting)
• Smart plugs (automated equipment)
• Do Not Disturb (automated on all devices)

Advanced System Design

The Compound System

Don’t just automate one thing. Chain automations.

Example: Morning Learning Routine

7:00 AM: Smart lights turn on gradually

→ 7:10 AM: Coffee maker starts (smart plug)

→ 7:15 AM: Alarm goes off

→ 7:20 AM: Anki opens automatically

→ 7:25 AM: After Anki reviews, browser opens to today’s reading

→ 7:40 AM: Reading tracker prompts for summary

→ 7:45 AM: Summary saved to learning journal

→ 7:50 AM: Calendar blocks for coding practice

→ 8:00 AM: IDE opens to yesterday’s work

Each step triggers the next. No decisions required.

The Adaptive System

Systems that adjust based on performance.

Example: Difficulty Scaling

If (last 3 problems solved in <20 mins):
    Increase difficulty
Else if (last 2 problems took >60 mins):
    Decrease difficulty
Else:
    Maintain difficulty

This keeps you in the zone of proximal development automatically.

The Recovery System

Systems that handle missed days.

Example: Streak Recovery

If streak breaks:

• Don’t reset to zero
• Start “recovery streak”
• Recovery streak of 7 days restores main streak
• Prevents all-or-nothing thinking

If two days missed:

• Automated message to accountability partner
• Increased check-ins for next week
• System adjusts to make practice easier temporarily

The goal: Resilience, not perfection.

Common Mistakes

Mistake 1: Over-Automation Too Soon

The trap: Build complex systems before you know what works.

The fix: Start manual. Automate what you find yourself repeating.

Example:

Don’t: Build complex workout tracking before you’ve worked out consistently for a month.

Do: Track manually for a month. Then automate the tracking.

Mistake 2: Automation Without Accountability

The trap: Automate triggers but not consequences.

Example: IDE opens automatically, but you can just close it.

The fix: Add accountability. Closing without practicing has a cost.

Mistake 3: No Escape Valve

The trap: Systems so rigid they break when life happens.

Example: System charges you $50 if you miss a day, even if you’re sick.

The fix: Build in flexibility for legitimate exceptions.

Mistake 4: Measuring the Wrong Thing

The trap: Optimize for metrics that don’t matter.

Example: Tracking “time spent” instead of “problems solved.”

Result: You game the system (keep timer running while browsing).

The fix: Measure outcomes, not just effort.

Mistake 5: Systems Without Feedback Loops

The trap: Automate practice but not learning from practice.

Example: Solve problems daily but never review mistakes.

The fix: System should prompt reflection, not just repetition.

Final Thoughts

For years, I tried to be more disciplined.

I’d set goals. Make plans. Use willpower.

It worked for a few days. Then failed.

The problem wasn’t me. It was the approach.

Willpower is finite. Systems are infinite.

Now I don’t try to remember to practice.

My systems practice for me:

• My calendar reminds me
• My IDE opens automatically
• My website blocker forces focus
• My accountability partner checks in
• My dashboard shows progress
• My financial stakes prevent skipping

I removed every excuse.

I removed every decision point.

I made practice the path of least resistance.

And now I practice consistently without thinking about it.

You don’t need more discipline.

You need better systems.

Stop relying on willpower.

Start building systems that practice for you.

Automate the triggers.

Remove the friction.

Add the accountability.

Track the progress.

Let the system do the work.

What’s one skill you want to practice consistently? What system could you build to make it automatic?