deliberate-practice

Apply deliberate practice principles for rapid skill acquisition and expert-level performance. Use when learning new skills, plateauing in development, designing training routines, or seeking to accelerate expertise acquisition.

210 stars

Best use case

deliberate-practice is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Apply deliberate practice principles for rapid skill acquisition and expert-level performance. Use when learning new skills, plateauing in development, designing training routines, or seeking to accelerate expertise acquisition.

Teams using deliberate-practice should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/deliberate-practice/SKILL.md --create-dirs "https://raw.githubusercontent.com/flpbalada/my-opencode-config/main/skills/deliberate-practice/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/deliberate-practice/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How deliberate-practice Compares

Feature / Agentdeliberate-practiceStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Apply deliberate practice principles for rapid skill acquisition and expert-level performance. Use when learning new skills, plateauing in development, designing training routines, or seeking to accelerate expertise acquisition.

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

Related Guides

SKILL.md Source

# Deliberate Practice & Skill Acquisition

Structured approach to improving performance through focused effort, feedback, and
continuous refinement. Based on psychologist K. Anders Ericsson's research on
expertise acquisition.

## When to Use This Skill

- Learning a new technical skill or programming language
- Plateauing in skill development and seeking to break through
- Designing personal training or practice routines
- Onboarding new team members effectively
- Teaching others how to practice better
- Evaluating if practice sessions are productive

## Core Principle

**Performance = Intentional Effort + Immediate Feedback + Progressive Challenge**

Deliberate practice contrasts with naive practice (mindless repetition). The difference
is the difference between 10 years of experience and 1 year of experience repeated
10 times.

## The 4 Key Elements

### 1. Focused Attention

Concentrate fully on the skill being practiced. Eliminate distractions. Quality of
attention directly impacts rate of improvement.

### 2. Immediate Feedback

Know immediately what you did wrong and how to correct it. Without rapid correction,
errors become ingrained habits.

### 3. Progressive Challenge

Operate at the edge of current abilities. If it's comfortable, you're not growing.
If it's too hard, you're building bad habits.

### 4. Repetition with Reflection

Repeat the specific subskill, reflect on results, adjust, then repeat. Not
repetition alone—iterative refinement.

## Mental Models

### The Performance Curve

```
Skill Level
    │
    │    ╱
    │   ╱  Comfort zone (no growth)
    │  ╱─────────────────────
    │ ╱
    │╱  Challenge zone (growth)
    │╲  (deliberate practice)
    │ ╲
    │  ╲_____________________
    │   Grown zone
    └────────────────────────── Time
```

### Ericsson's Rule of 10 Years

Research across multiple domains (musicians, chess masters, surgeons) shows:
~10 years or ~10,000 hours of deliberate practice to reach expert level.

**Not innate talent—deliberate practice is the differentiator.**

## Techniques

### 1. Isolation & Segmentation

Break the skill into subcomponents. Practice the weakest component in isolation
until mastered, then integrate.

**Example**: A pianist doesn't practice the entire piece, but the 4 bars that are
difficult. A programmer doesn't "build an app" but practices specific patterns
or algorithms.

### 2. Time Boxing with Breaks

- Practice in 60-90 minute focused sessions
- Take 5-10 minute breaks between sessions
- Maximum 4 hours of deliberate practice per day
- Mental fatigue eliminates the focused attention required

### 3. Mental Rehearsal

Visualize performing the skill correctly. Activates same neural pathways as physical
practice. Particularly useful for skills with high mental component.

### 4. Speed Reduction

Slow down the skill to 50% speed. Errors become more visible and corrections more
precise. Master at slow speed, then accelerate.

### 5. Calibration Sessions

Periodically test yourself under conditions mimicking real performance to calibrate
actual vs. perceived ability. Bridge the gap between practice environment and
real-world application.

## Deliberate Practice vs. Kaizen

| Aspect           | Deliberate Practice            | Kaizen                        |
| ---------------- | ------------------------------ | ----------------------------- |
| **Focus**        | Individual skill mastery       | Organizational improvement    |
| **Goal**         | Expert-level performance       | Incremental, sustainable gains|
| **Method**       | Targeted weakness training     | Systematic waste elimination  |
| **Feedback**     | Immediate, self-corrective    | Team-based, observation-driven|
| **Scope**        | Personal capability           | Entire value stream           |

**Synergy**: Apply deliberate practice principles to kaizen events—focus on specific
pain points, get rapid feedback, incrementally improve.

## Zone Indicators

### Signs You're in the Challenge Zone (Growth Zone)

- Making mistakes frequently
- Feeling uncomfortable
- Slow progress (but real progress)
- High mental effort required
- Frequently needing to pause and recalibrate

### Signs You're in the Comfort Zone (No Growth)

- Automatic execution without thought
- No mental effort required
- Making no mistakes (means it's too easy)
- Boredom

### Signs You're Beyond Challenge Zone (Frustration)

- Constant failures without learning
- Unable to identify what to adjust
- Complete confusion without direction

## Questions for Effective Practice

Before each session, ask:

1. What specific subskill am I developing today?
2. What is my immediate feedback mechanism?
3. How is today's practice harder than yesterday's?
4. What did I learn from the last session?

After each session, ask:

1. What specifically did I improve?
2. What still needs work?
3. What will I focus on next session?
4. How does this connect to the larger skill?

## Common Pitfalls

| Pitfall                                    | Why It Happens                    | Solution                        |
| ------------------------------------------ | -------------------------------- | ------------------------------- |
| Spending time on mastered skills           | Feels good, no discomfort        | Track time-boxed to weak areas  |
| Not seeking feedback; assuming improvement | Complacency, lack of humility     | Build in external verification  |
| Practicing without clear, specific goals  | "Just practice" has no direction | Define subskill before starting |
| Relying on talent rather than effort     | Fixed mindset                    | Focus on process over aptitude  |
| Practicing same thing the same way        | Avoids discomfort                | Increase difficulty each session|
| No rest between sessions                  | Rushing, overconfidence          | Respect cognitive recovery time |

## Application to Software Development

### Before Writing Code

- Define the specific skill target (e.g., "understand recursion patterns")
- Identify your feedback mechanism (tests, code review, execution)

### During Practice

- Write one function, not entire programs
- Get immediate feedback from tests or REPL
- If stuck, slow down and isolate the concept

### After Practice

- Reflect: What did the errors teach me?
- Connect: How does this pattern apply broadly?

### Practice Routine Examples

| Skill Target          | Isolation Practice             | Feedback Mechanism      |
| --------------------- | ------------------------------- | ---------------------- |
| Debugging             | Reproduce bugs in controlled way| Root cause analysis   |
| Algorithm design     | Solve one algorithm type        | Test cases, complexity|
| API design           | Design one endpoint              | Code review           |
| Refactoring          | Transform one pattern            | Tests pass before/after|
| Learning a new language | Implement basic patterns      | Exercises, compiler   |

## Resources

- **K. Anders Ericsson** — *Peak: Secrets from the New Science of Expertise*
- **Anders Ericsson** — *The Role of Deliberate Practice in the Acquisition of Expert
  Performance* (academic paper)
- **Josh Waitzkin** — *The Art of Learning* (an athlete's journey applying deliberate
  practice principles)

Related Skills

typescript-best-practices

210
from flpbalada/my-opencode-config

Guides TypeScript best practices for type safety, code organization, and maintainability. Use this skill when configuring TypeScript projects, deciding on typing strategies, writing async code, or reviewing TypeScript code quality.

code-architecture-tailwind-v4-best-practices

204
from flpbalada/my-opencode-config

Guides Tailwind CSS v4 patterns for buttons and components. Use this skill when creating components with variants, choosing between CVA/tailwind-variants, or configuring Tailwind v4's CSS-first approach.

what-not-to-do-as-product-manager

210
from flpbalada/my-opencode-config

Anti-patterns and mistakes to avoid as a product manager. Use when evaluating leadership behaviors, improving team dynamics, reflecting on management practices, or onboarding new product managers.

visual-cues-cta-psychology

210
from flpbalada/my-opencode-config

Design effective CTAs using visual attention and gaze psychology principles. Use when designing landing pages, button hierarchies, conversion elements, or optimizing user attention flow through interfaces.

vercel-sandbox

210
from flpbalada/my-opencode-config

Run agent-browser + Chrome inside Vercel Sandbox microVMs for browser automation from any Vercel-deployed app. Use when the user needs browser automation in a Vercel app (Next.js, SvelteKit, Nuxt, Remix, Astro, etc.), wants to run headless Chrome without binary size limits, needs persistent browser sessions across commands, or wants ephemeral isolated browser environments. Triggers include "Vercel Sandbox browser", "microVM Chrome", "agent-browser in sandbox", "browser automation on Vercel", or any task requiring Chrome in a Vercel Sandbox.

value-realization

210
from flpbalada/my-opencode-config

Analyze if end users discover clear value. Use when evaluating product concepts, analyzing adoption, or uncertain about direction.

user-story-fundamentals

210
from flpbalada/my-opencode-config

Capture requirements from user perspective with structured user stories. Use when writing backlog items, defining acceptance criteria, prioritizing features, or communicating requirements between product and development.

typescript-satisfies-operator

210
from flpbalada/my-opencode-config

Guides proper usage of TypeScript's satisfies operator vs type annotations. Use this skill when deciding between type annotations (colon) and satisfies, validating object shapes while preserving literal types, or troubleshooting type inference issues.

typescript-interface-vs-type

210
from flpbalada/my-opencode-config

Guides when to use interface vs type in TypeScript. Use this skill when defining object types, extending types, or choosing between interface and type aliases.

typescript-advanced-types

210
from flpbalada/my-opencode-config

Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.

trust-psychology

210
from flpbalada/my-opencode-config

Build trust signals that reduce perceived risk and enable user action. Use when designing landing pages, checkout flows, onboarding experiences, or any conversion point where user hesitation is a barrier.

theme-epic-story

210
from flpbalada/my-opencode-config

Structure product work hierarchically using themes, epics, and stories. Use when organizing backlogs, planning releases, communicating with stakeholders, or breaking down large initiatives into manageable work.