Preparation & Mindset = Skill

Skill, or performance in a specific context is not innate. It is built through the deliberate interaction of preparation and mindset. Talent might give someone a head start early on, or determine the very best of the best, but otherwise sustained performance is dominated by these two forces.

Mindset

Before performance can be improved, one must decide what level of performance matters. Mindset isn't about affirmations. It's about drawing a clear, often uncomfortable line in the sand.
- "I don’t ever want to be the reason my team fails."
- "I want to be trusted with strategic technical decisions."
- "I want to be world-class at this."

These aren’t goals, they’re standards. They define what "acceptable" looks like to you. They shape how you show up, what you commit to, and what you’re unwilling to tolerate in yourself. If your mindset is vague, your preparation will be misaligned, and your growth will stall.

This step sometimes requires recalibration as you progress. You might want to be elite in something like competitive golf, but balk when faced with the lifestyle and sacrifices required. That’s valid. But you need to be honest. Desire without alignment is fantasy.

Preparation

Once the standard is clear, preparation becomes a series of deliberate steps aimed at reducing the gap between where you are and where your mindset says you should be.

Preparation involves:
- Knowledge acquisition: Understanding the field, its expectations, its culture.
- Skill-building: Practice, repetition, and feedback cycles.
- Environment shaping: Choosing tools, collaborators, or systems that reinforce performance.
- Reflection and iteration: Reviewing your performance, identifying bottlenecks, and adjusting.

The higher your standard, the more intense your preparation must be.

One of the greatest challenges in preparation is that you don't know what you don't know. Many people stall because they can't envision what proper preparation looks like at higher levels. To overcome this blind spot:

Find mentors or role models: Study how top performers in your field prepare. What do they read? How do they practice? What tools do they use?
Join communities of practice: Participate in groups where preparation methods are discussed openly.
Analyze the performance gap: When you encounter someone operating at a higher level, ask yourself: "What knowledge or skills might they have that I don't?"
Seek direct feedback: Ask those with more experience to evaluate not just your performance, but your preparation routine.

Skill

The transformation from Preparation + Mindset to Skill happens through a cycle of action and reinforcement.

By setting a clear standard, you filter out distractions and prioritize relevant development. When you know exactly what matters, your learning becomes targeted rather than scattered. The right practice creates visible improvement, which provides evidence that your approach works.

This cycle explains why some people seem to learn faster or perform better even with similar amounts of practice - their preparation is guided by a clearer mindset, which creates an efficiency that accumulates over time.

Contrast Example

To make this more concrete, here are two example mindsets and how they shape preparation. These are not value judgments - they're simplified archetypes meant to show how different internal standards lead to different growth paths.

Developer A: Steady Contributor

Codes during work hours, minimal tech engagement outside work
Solves tickets using familiar patterns and tools
Avoids architectural choices or ambiguous problems
Rarely reads technical articles, changelogs, or documentation beyond immediate needs
Uninterested in feedback unless it blocks deployment
Doesn’t reflect much on how things could be done better

Mindset: “As long as I get the job done well, that’s enough.”
Preparation: Day-to-day repetition. Occasional learning when forced by task.
Skill Outcome: Baseline competence. Dependable for well-scoped work.

Developer B: Technical Polymath

Studies runtimes, architectures, and language design out of curiosity
Builds tooling to solve pain points at work and in side projects
Reads books, papers, and production code to improve mental models
Actively seeks feedback, reads code reviews deeply, and experiments with different solutions
Teaches and mentors others to sharpen their own understanding
Reflects often on what could be improved and how

Mindset: “I want to deeply understand and master my craft.”
Preparation: Strategic, multi-dimensional—study, build, reflect, teach, repeat.
Skill Outcome: Deep, transferable expertise. High adaptability, systems-level thinking.

I want to emphasize again that neither is the wrong choice. Assuming the mindset has been consciously defined - based on personal values, goals, and tradeoffs - both paths are valid. Not everyone needs or wants to be elite in their field, and choosing stability over intensity can be a wise, self-aware decision. Problems arise only when the mindset is vague or aspirational but not supported by preparation. Clarity about what matters to you is the foundation; the rest is alignment.

Example Preparation Framework

Below is a sample preparation framework for software development. It’s not exhaustive or definitive - it’s meant to illustrate how mindset translates into structured preparation across different levels of competence.

Software Development (Web) Example

🟢 Fundamentals (Baseline Competence)

Completes a few beginner-friendly tutorials or courses and finishes the projects
Builds a few small tools or apps (e.g. a to-do list, blog, API wrapper) from scratch without copy-pasting
Practices using version control daily: branches, merges, resolving conflicts, reading diffs
Uses the debugger instead of console.log for familiarity
Sets up a basic local dev environment: code editor with extensions, terminal shortcuts, linting/prettier
Googles actively and learns to ask better questions; bookmarks docs and error solutions
Joins a beginner-friendly Discord or forum
Deploys at least one project publicly (e.g. Vercel, Render, Heroku) and shares it with someone for technical feedback

📈 Result: Can solve basic problems with some support. Starts forming good habits around tooling and feedback.

🔵 Intermediate (Prepared and Useful)

Builds small/medium-scope projects (~1k–5k LOC) end-to-end: backend, frontend, auth, persistence, deploy
Breaks features into small tasks, estimates time, and tracks blockers
Starts contributing to open source or improving internal tooling at work
Adds CI pipelines to projects and configures tests, linters, type-checkers
Builds mental models for HTTP, databases, and JavaScript runtimes by reading docs + running test code
Keeps a “dev scratchpad” to document discoveries, weird bugs, or key takeaways from tasks
Reads 1–2 foundational books (e.g. A Philosophy of Software Design, Clean Code, Designing Web APIs, ) and applies techniques to personal projects
Asks for code review regularly and revises code based on feedback
Practices pair programming or walkthroughs to improve explanation and debugging fluency

📈 Result: Comfortable in production codebases. Bridges theory and practice. Grows through structure, not just exposure.

🟣 Advanced (Architecturally Aware)

Conducts focused code reading sessions: picks a mature open-source repo and traces a feature end-to-end
Keeps a "why did we do it this way?" journal to capture architectural decisions and tradeoffs on the job
Intentionally rotates between frontend/backend/devops projects to broaden context and reduce blind spots
Practices system design by sketching different architectures for real or imagined problems, evaluating pros/cons
Benchmarks tools, frameworks, or protocols (e.g. REST vs gRPC) to understand real-world performance costs
Rewrites project components to explore different patterns (e.g. functional core / imperative shell, CQRS, hexagonal)
Makes performance a habit: profiles code before optimizing, and tests theories with data
Participates in team architecture reviews or RFCs, asking clarifying questions and suggesting simplifications

📈 Result: Builds robust, understandable systems. Thinks in tradeoffs, not checklists. Trusted with high-leverage design work.

🔴 Elite (Top Percentile Mindset)

Regularly re-reads foundational texts (Structure and Interpretation of Computer Programs, Designing Data-Intensive Applications, etc.) and applies new insights to real projects
Dives into language/runtime internals: reads source code, contributes to issues, traces execution with debuggers/profilers
Builds minimal clones of core systems (e.g. in-memory DB, message queue, HTTP server) to internalize concepts
Investigates historical systems (e.g. Erlang, UNIX, Postgres) to understand design tradeoffs and longevity
Conducts technical deep-dives with peers: discusses architecture, reads papers, and critiques designs collaboratively
Leads postmortems and architecture reviews, identifying not just what failed but how systems can evolve
Builds intuition for complexity: runs experiments, sketches ideas, tests assumptions in isolated PoCs
Writes long-form reflections or design documents articulating hard-won insights
Participates in or hosts advanced reading groups or workshops (e.g. papers we love, deep internals sessions)

📈 Result: Has internalized principles across the stack. Navigates novelty through first principles. Inspires and elevates others through clarity and rigor.

Creating Your Own Preparation Framework

The examples below demonstrate how preparation varies across skill levels. To create your own framework:

Define your target level: Be honest about where you want to be.
Study practitioners at that level: What do they do daily? What resources do they use? What habits have they formed?
Identify skill components: Break down the domain into 3-5 core competencies (e.g., technical knowledge, tool proficiency, communication).
Create concrete actions for each component: What specific, measurable activities build each competency?
Establish a progression ladder: For each component, define clear steps from fundamentals to mastery.
Build feedback loops: How will you know if your preparation is effective? Who can evaluate your progress?
Schedule regular reviews: Set times to assess whether your preparation aligns with your mindset and adjust accordingly.

The most effective frameworks are specific, actionable, and aligned with your personal standards.

PMS Framework