Addy Osmani is a software engineer, author, and engineering leader known for his work on Chrome developer experience, web performance, JavaScript architecture, and AI-assisted software development. — Addy Osmani — About.

Visual summary of operating lessons from Addy Osmani.

Part 1: The Craft of Software Engineering

  1. Ship, Then Improve: Start with a real prototype, learn from contact with users, and improve the implementation in successive passes. — Addy Osmani — 21 Lessons From 14 Years at Google.
  2. Write for the Next Maintainer: Treat code as communication: keep it readable, intentional, and considerate of the person who must change it later. — Addy Osmani — Good Code Is a Love Letter.
  3. Start With the User Problem: High-impact engineers work backward from a deeply understood user problem instead of searching for uses for a favored technology. — Addy Osmani — 21 Lessons From 14 Years at Google.
  4. Use Small, Recoverable Actions: Move quickly by taking the smallest responsible step that produces real feedback, with tests, monitoring, and rollback ready. — Addy Osmani — Bias Toward Action.
  5. Watch Comprehension Debt: When code grows faster than human understanding, teams accumulate a dangerous gap between what exists and what anyone can confidently explain. — Addy Osmani — Comprehension Debt.

Part 2: Design Patterns & Architecture

  1. Use Patterns as Shared Vocabulary: Design patterns give developers a common language for discussing recurring architectural choices and tradeoffs. — Addy Osmani — Good Code Is a Love Letter.
  2. Apply Patterns Pragmatically: Choose a pattern only when it clarifies a concrete problem; dogmatic pattern use creates needless complexity. — Addy Osmani — Good Code Is a Love Letter.
  3. Match Rendering to Product Needs: Choose among server rendering, static generation, hydration, and island-style approaches according to the experience and interactivity required. — Learning JavaScript Design Patterns.
  4. Prefer the Simplest Adequate Design: Treat patterns as a toolbox rather than a rulebook, and avoid forcing a sophisticated structure onto a simple problem. — Addy Osmani — Good Code Is a Love Letter.
  5. Use Architecture as a Safety Net: Deliberate architecture and boundaries help teams contain AI-generated debt while retaining human control of the system. — Addy Osmani — Software Factories, Light and Dark.

Part 3: Performance Mindset

  1. The Fastest Request Is the One You Avoid: Question whether every asset is necessary before optimizing its delivery; removal often produces the cleanest performance gain. — Addy Osmani — Essential Image Optimization.
  2. Optimize for User Experience: Measure whether content appears, becomes usable, and stays responsive instead of treating network completion as the whole experience. — Addy Osmani — Web Page Usability Matters.
  3. Measure Before Optimizing: Profile real loading and execution behavior so performance work targets observed bottlenecks rather than intuition. — Addy Osmani — Web Page Usability Matters.
  4. Budget for JavaScript’s Full Cost: JavaScript costs include downloading, decompressing, parsing, compiling, and main-thread execution—especially on constrained devices. — Addy Osmani — The Cost of JavaScript.
  5. Adapt Delivery to the Device: Serve a fast core experience to everyone, then add heavier media and interactivity only when network and hardware conditions support them. — Addy Osmani — Adaptive Loading.
  6. Make Performance a Budget: Define explicit limits for bundle size, requests, or user-centric metrics and enforce them before regressions reach production. — Addy Osmani — Start Performance Budgeting.
  7. Do Not Assume Fast Hardware: Design and test for median mobile CPUs, memory, and networks rather than using a developer workstation as the performance baseline. — Addy Osmani — The Cost of JavaScript.
  8. Remove Before You Optimize: Prioritize what creates value for users and eliminate scripts or assets that do not justify their cost. — Addy Osmani — The Cost of JavaScript.
  9. Automate Performance Guardrails: Put size budgets and performance checks in CI so regressions are caught as part of the build rather than after release. — Addy Osmani — Start Performance Budgeting.

Part 4: Core Web Vitals & Measurement

  1. Use Shared User-Centric Metrics: Core Web Vitals give teams a common framework for assessing loading, responsiveness, and visual stability. — Addy Osmani — The History of Core Web Vitals.
  2. Combine Lab and Field Evidence: Use diagnostic lab tools alongside field data from real users; neither view is sufficient on its own. — Addy Osmani — Web Page Usability Matters.
  3. Treat LCP as a User-Visible Milestone: Largest Contentful Paint tracks when the page’s primary visible content has rendered, making it useful for prioritizing critical resources. — Addy Osmani — Preload Late-Discovered Hero Images.
  4. Protect Visual Stability: Reserve space and control late-loading content so users are not disrupted by unexpected layout movement. — Addy Osmani — The History of Core Web Vitals.
  5. Responsiveness Matters After Paint: A page that looks ready but cannot promptly respond to input still feels slow; monitor main-thread work and interaction readiness. — Addy Osmani — Web Page Usability Matters.
  6. Monitor Performance Continuously: Performance metrics regress as features ship, so budgets and field monitoring must remain part of ongoing development. — Addy Osmani — Start Performance Budgeting.
  7. Lighthouse Is Diagnostic, Not Reality: A local audit helps find problems, but real-user conditions and field measurements are needed to understand production experience. — Addy Osmani — Web Page Usability Matters.

Part 5: Image & Asset Optimization

  1. Start With Image Weight: Images are often the largest share of page bytes, making format, dimensions, and compression high-leverage optimization targets. — Addy Osmani — Essential Image Optimization.
  2. Use Modern Image Formats Deliberately: AVIF and WebP can reduce payloads substantially, but format choice should be tested against quality, decoding, and browser support. — Addy Osmani — Essential Image Optimization.
  3. Make the Image Element Work for You: Use responsive sources, dimensions, loading behavior, and priority hints so the browser can choose and schedule images effectively. — Addy Osmani — Essential Image Optimization.
  4. Lazy-Load Offscreen Images: Defer images outside the viewport to reduce initial bandwidth and memory work while keeping likely in-viewport content eager. — Addy Osmani — Native Image Lazy-Loading.
  5. Serve the Right Image Size: Responsive image candidates let the browser avoid downloading pixels that the current viewport and display cannot use. — Addy Osmani — Essential Image Optimization.
  6. Compress Transferable Text: Enable Brotli or gzip for compressible text resources so users do not pay unnecessary transfer costs. — Addy Osmani — Essential Image Optimization.
  7. Preload Only Critical Late-Discovered Assets: Preload can improve LCP when a hero resource is discovered late, but overuse competes with resources the browser already prioritizes. — Addy Osmani — Preload Late-Discovered Hero Images.
  8. Version Long-Lived Cached Assets: Use hashed filenames and explicit cache policies so repeat visits benefit from caching without preventing safe updates. — Addy Osmani — Application Shell Architecture.

Part 6: JavaScript & Tooling

  1. Split Code Around Actual Use: Fine-grained code splitting reduces initial download and execution by loading features when their route or interaction needs them. — Addy Osmani — The Cost of JavaScript.
  2. Eliminate Code Users Never Execute: Combine tree-shaking and coverage analysis with careful dependency choices to keep unused library code out of production bundles. — Addy Osmani — The Cost of JavaScript.
  3. Inspect the Bundle, Not Just the Source: Regularly analyze production output for duplicate dependencies, oversized modules, and code that can be deferred or removed. — Addy Osmani — The Cost of JavaScript.
  4. Audit Third-Party Scripts Ruthlessly: Third-party code competes for bandwidth and main-thread time, so load it only when its user value justifies its performance cost. — Addy Osmani — The Cost of JavaScript.
  5. Account for Framework Runtime Cost: Frameworks improve developer productivity, but their client-side download, hydration, and execution costs still belong in the user-experience budget. — Addy Osmani — The Cost of JavaScript.
  6. Load Heavy Features on Demand: Dynamic imports and progressive loading keep rarely used functionality off the critical path. — Addy Osmani — The Cost of JavaScript.
  7. Break Up Long Main-Thread Tasks: Long-running JavaScript blocks input and delays interactivity; reduce execution and split work so the browser can respond. — Addy Osmani — The Cost of JavaScript.
  8. Turn the Build Into a Gatekeeper: Use CI budgets and automated checks to reject oversized bundles and measurable performance regressions before deployment. — Addy Osmani — Start Performance Budgeting.

Part 7: AI & The Future of Development

  1. Treat AI Output as a Draft: AI can accelerate implementation, but convincing output still requires human review, tests, and proof that the change meets its intent. — Addy Osmani — The 80% Problem in Agentic Coding.
  2. Plan for the Last Mile: Agents can generate most of an implementation quickly while integration, edge cases, maintainability, and verification remain expensive. — Addy Osmani — The 80% Problem in Agentic Coding.
  3. Do Not Let Code Outrun Understanding: AI-generated volume can create comprehension debt when nobody maintains a reliable mental model of the resulting system. — Addy Osmani — Comprehension Debt.
  4. Senior Work Moves Toward Orchestration: As agents handle more implementation, senior engineers spend more effort on architecture, specifications, review, and accountable decisions. — Addy Osmani — Agentic Engineering.
  5. Avoid Cognitive Surrender: Delegation becomes surrender when an agent’s answer is accepted without the human retaining judgment, understanding, and responsibility. — Addy Osmani — Cognitive Surrender.
  6. Verification Becomes the Bottleneck: When code generation accelerates, the binding constraint shifts to how quickly a trusted reviewer can establish correctness. — Addy Osmani — Agentic Code Review.
  7. Keep Engineering Rigor Around Agents: Reliable agent-assisted development still begins with a plan and depends on architecture, review, tests, version control, and human ownership. — Addy Osmani — Agentic Engineering.
  8. Do Not Outsource the Learning: Use AI to accelerate work without skipping the effort required to build and refresh your own technical mental models. — Addy Osmani — Don’t Outsource the Learning.
  9. Govern Autonomy With Constraints: As agents become more autonomous, teams need explicit permissions, sandboxes, tests, review gates, and accountable owners. — Addy Osmani — Software Factories, Light and Dark.
  10. Engineer the Loop, Not Just the Prompt: Reliable agent work comes from repeatable loops that combine context, execution, evaluation, and correction. — Addy Osmani — Loop Engineering.
  11. Separate Writing From Checking: Use an independent reviewing agent or verification stage because a system is often too forgiving when judging its own output. — Addy Osmani — Loop Engineering.
  12. Think in Software Factories: A software factory coordinates multiple constrained loops through queues and review gates while keeping humans accountable for outcomes. — Addy Osmani — Software Factories, Light and Dark.
  13. Build Automated Back Pressure: Autonomous loops need frequent, inexpensive checks that stop low-quality work before it compounds. — Addy Osmani — Software Factories, Light and Dark.
  14. Isolate Parallel Agents: Use separate worktrees or sandboxes so concurrent agents do not collide in the same working state. — Addy Osmani — Loop Engineering.
  15. Account for the Orchestration Tax: Starting more agents does not multiply human attention; steering, context switching, and verification can become the new bottleneck. — Addy Osmani — Own the Outer Loop.
  16. Improve Specifications as Implementation Gets Cheaper: When agents can produce code quickly, clear intent, constraints, and acceptance criteria become the scarce inputs. — Addy Osmani — The New Software Lifecycle.
  17. Debug the Harness, Not Only the Model: Agent failures often come from missing context, weak tools, poor rules, or inadequate feedback loops in the surrounding system. — Addy Osmani — The New Software Lifecycle.
  18. Write Down the Why: Externalize goals, constraints, and architectural rationale because an agent can infer plausible intent but cannot recover the real intent that was never recorded. — Addy Osmani — The Intent Debt.

Part 8: Engineering Leadership & Career

  1. Know the Decision a Meeting Must Produce: Before scheduling a mission-oriented meeting, define its objective, participants, agenda, and expected decision. — Addy Osmani — Focus on High-Leverage Activities.
  2. Cultivate High Agency: High-agency engineers clarify weak requirements, unblock themselves, and proactively improve the system rather than waiting for perfect instructions. — Addy Osmani — High Agency Matters.
  3. Redefine Output When You Become a Manager: Engineering leadership shifts impact from personal code production toward better decisions, healthier systems, and stronger team execution. — Addy Osmani — Engineering Leadership Guide.
  4. Architecture Requires Social Skill: Senior technical roles depend on communication, alignment, judgment, and productive disagreement as much as technical depth. — Addy Osmani — Engineering Leadership Guide.
  5. On Agentic high agency: High agency means knowing when to delegate, inspect, stop, and personally own the outcome. — Addy Osmani: Own the Outer Loop