From understanding
to ownership.

Build depth in one language and learn supporting tools as the work requires.

• Choose a language for a problem and explain the tradeoffs.
• Read unfamiliar code and distinguish programming, markup, and configuration.

Explain why your code behaves as it does, from types to runtime behavior.

• Reason about scope, mutation, types, errors, and resource cleanup.
• Use the standard library and appropriate programming styles.

Select practical representations and understand their costs.

• Compare time and space complexity for common operations.
• Use collections, searching, sorting, and traversal with clear tradeoffs.

Use the reasoning tools your field needs, with deeper mathematics where relevant.

• Apply logic, sets, basic probability, and discrete reasoning.
• Recognize when a problem needs numerical or statistical expertise.

Work confidently in a shared codebase.

• Use a debugger, shell, editor, and version control effectively.
• Review changes, resolve conflicts, and preserve useful project history.

Understand the environment in which programs execute.

• Explain processes, threads, memory, files, and resource limits.
• Connect runtime behavior to practical correctness and performance.

Trace a request across the systems it depends on.

• Explain DNS, transport, TLS, HTTP, and caching.
• Investigate latency, timeouts, and network failure.

Represent information and protect its meaning as a system changes.

• Design schemas, queries, indexes, and transactions.
• Plan migrations, backups, and recovery for data-backed applications.

Reason about work that overlaps and systems that fail independently.

• Explain synchronization, consistency, retries, and idempotency.
• Choose an appropriate level of distributed-system complexity.

Make code easier to understand, test, and change.

• Design cohesive modules with explicit responsibilities.
• Refactor incrementally and manage coupling and technical debt.

Make and explain design decisions within a concrete domain.

• Compare options against requirements and operational constraints.
• Document boundaries, failure modes, and architectural tradeoffs.

Build dependable contracts between services and their consumers.

• Design validation, authorization, pagination, and error behavior.
• Handle versioning, rate limits, webhooks, and integration failures.

Collect useful evidence that a change behaves as intended.

• Choose unit, integration, contract, and end-to-end tests by risk.
• Write reproducible tests for failure paths and regressions.

Investigate with evidence before changing code.

• Reproduce a problem, form hypotheses, and isolate its cause.
• Profile and benchmark with realistic workloads and explicit limits.

Build security into everyday design and implementation.

• Validate trust boundaries, access control, and untrusted input.
• Manage secrets and dependencies and investigate common attack paths.

Consider the people affected by technical decisions.

• Minimize data collection and reason about retention and access.
• Identify ethical risks and when specialist review is needed.

Make software reproducible beyond your own machine.

• Manage versions, dependency locks, and build artifacts.
• Understand supply-chain trust and maintain dependencies over time.

Ship changes through a repeatable, observable process.

• Automate relevant checks and controlled deployment.
• Plan configuration, rollout, rollback, and release verification.

Understand the infrastructure your software needs; specialize where your role requires.

• Reason about compute, storage, networking, identity, and cost.
• Apply containers or infrastructure as code when they serve the system.

Care for systems after they are deployed.

• Use logs, metrics, traces, and service objectives to diagnose behavior.
• Prepare runbooks and turn incidents into actionable improvements.

Own the complete life of a system, including its final chapter.

• Plan compatibility, migrations, support, and deprecation.
• Retire services and data responsibly with a clear transition plan.

Create responsive, understandable experiences on the web.

• Work with HTML, CSS, JavaScript, browser APIs, and state.
• Evaluate performance, forms, rendering, and browser behavior.

Build user-facing products people can actually use.

• Support semantic structure, keyboard navigation, and assistive technology.
• Test clear feedback, errors, and usability with real tasks.

Work with mobile platforms and their real constraints.

• Reason about lifecycle, permissions, storage, and connectivity.
• Plan platform testing, distribution, updates, and battery use.

Design for the messy environments in which people use software.

• Handle locales, time zones, formats, and unreliable connectivity.
• Consider abuse, support, and operational edge cases in your domain.

Choose additional depth for the work you want to do.

• Recognize distinct paths such as embedded, graphics, compilers, or scientific computing.
• Identify the domain expertise and evidence your chosen specialty requires.

Use AI deliberately where permitted and verify the result.

• Review generated code, tests, and explanations against evidence.
• Protect sensitive context and recognize when AI adds little value.

Design useful products around probabilistic model behavior.

• Work with retrieval, structured output, tools, and model integration.
• Evaluate latency, cost, permissions, and fallback behavior.

Measure behavior before giving AI systems consequential autonomy.

• Build representative evaluations and monitor failures and regressions.
• Bound tool access, test injection risks, and provide human oversight.

Develop models with sound data and experimental practice.

• Prevent leakage and compare against meaningful baselines.
• Evaluate generalization, deployment behavior, and model drift.

Build dependable pipelines that preserve the meaning of data.

• Design ingestion, transformation, schemas, and data-quality checks.
• Reason about batch and streaming work, lineage, and recovery.

Connect engineering work to a real problem and a worthwhile outcome.

• Clarify uncertain requirements and choose useful measures of success.
• Plan work around value, cost, risk, and feedback.

Make technical work understandable to the people who depend on it.

• Write useful documentation, proposals, and decision records.
• Give constructive reviews and communicate uncertainty clearly.

Help others become more effective as your own responsibility grows.

• Teach with context, offer actionable feedback, and share ownership.
• Lead technical work through ambiguity without becoming a bottleneck.

Extend technical influence across teams and organizational boundaries.

• Align technical direction with longer-term organizational needs.
• Build consensus, guide cross-team initiatives, and develop other leaders.