Wire repetitive web tasks out of existence. No permits required.
Wire repetitive web tasks out of existence. No permits required.
From $9/month·~9 hrs·5 chapters
5chapters
22lessons
13frameworks
“The browser is a building you didn't construct but desperately need to automate. You're a systems installer — threading wires into rooms, mounting control panels, wiring junction boxes, and running communication lines that make the whole structure intelligent. The occupants see the switches and the results, never the wiring. This metaphor works because extensions truly operate as invisible infrastructure within an existing structure, connecting components that were never designed to talk to each other.”
Curriculum
5 chapters, 22 lessons
The full expedition — every chapter and lesson. Tap a chapter to expand. Lessons unlock when you start.
⊘What Chrome Extensions Actually Are (And Aren't)
⊘The Four-Part Anatomy: Every Component and What It Does
⊘Why 'It Works on My Machine' Starts with Developer Mode
⊘Loading QuickWire v0.1: Your First Live Extension
⊘manifest.json Decoded: Every Field That Actually Matters
⊘Permissions Are Keys, Not Suggestions: Requesting Only What You Need
⊘Declaring Scripts, Pages, and the Service Worker Entry Point
⊘Versioning, Icons, and the Identity Your Extension Carries
⊘How Content Scripts Enter a Web Page Without Being Invited
⊘Reading and Rewriting the DOM Like You Own the Room
⊘CSS Injection: Repainting Walls Without Touching the Foundation
⊘Timing, Isolation, and the Sandbox You Can't Escape
⊘Building QuickWire's First Page Enhancement: Overdue Task Highlighter
⊘Popup HTML: Building Your Extension's Front Door
⊘Styling Popups That Don't Look Like They Were Built in 2005
⊘Options Pages: Giving Users Control of the Panel
⊘Wiring User Input to Extension Logic: Buttons, Forms, and Feedback
⊘The Vibe Coding Mindset: What AI Can and Can't Wire for You
⊘Prompting for Browser Code: The Inputs That Get Clean Output
⊘AI Builds the Scaffold, You Check the Connections
⊘Debugging AI-Generated Extension Code Without Losing Your Mind
⊘When to Vibe and When to Hand-Code: Building a Reliable Instinct
Why it's worth it
The credential that closes the gap
These frameworks map to roles hiring teams actively recruit for. Browse open jobs to see the market.
A few of the misconceptions this course clears up. The full set is inside.
“You can just start writing code and figure out the manifest.json later — it's just a config file you fill in at the end.”
RealityThe manifest.json is the schematic that governs every permission, every script injection point, every communication channel, and every UI surface your extension can ever have. Building code before the manifest is like running wire before you've drawn the schematic — you'll rip half of it out when reality catches up. Kaya's rule at RunWire: manifest first, always.
“Content scripts have full access to the page's JavaScript variables and functions — you can just read whatever the site's code is doing.”
RealityContent scripts run in an isolated world. They share the DOM with the page but operate in a completely separate JavaScript execution context. You can read and modify HTML elements, but you cannot access variables, functions, or objects defined by the page's own scripts. Dex discovered this the hard way trying to tap into Brevio's internal task object — the DOM was right there, the JS variable was invisible.
“The background service worker is always running and ready to receive messages — it's like a server that stays on.”
RealityService workers are not persistent. Chrome terminates them after a short period of inactivity and restarts them on demand. Any state you store in memory — variables, open connections, cached data — is gone when the worker goes to sleep. The JUNCTION Model exists precisely because the service worker is a routing box, not a power source. You must persist anything important to chrome.storage, not to a variable.
Frameworks you'll keep
Portable thinking tools
Named frameworks you'll carry into every AI decision long after the course.
You should have working knowledge of JavaScript fundamentals and basic web development (HTML/CSS). No prior browser extension experience is required—the course starts from ground-level architecture and builds systematically through all 13 frameworks.
Yes, entirely. The course is built around Manifest V3, the current Chrome standard. You'll master service workers, declarative net requests, modern permission models, and all API patterns required for Chrome Web Store approval.
Absolutely. Chapter 13 (the SHOPFRONT Protocol) covers the complete deployment lifecycle: packaging, privacy disclosure, store listing optimization, certification, and post-launch update management.
Chapter 5 teaches vibe coding—using AI tools to accelerate extension development. Chapter 10 (the AXON Method) shows you how to wire AI APIs directly into your extension for intelligent, adaptive automations that learn and respond.
You'll build content-injecting extensions, workflow automation tools, web scrapers, AI-enhanced browser assistants, productivity tools, and custom integrations that interact with live web applications in real time.
The course contains 57 hands-on lessons across 13 chapters. Each chapter introduces a proprietary framework (WALKAROUND, SCHEMATIC, SOLDER, etc.) that teaches a specific extension capability through practical, buildable examples.
Yes—this course is specifically designed for developers building intelligent browser extensions. It covers both the technical infrastructure (service workers, messaging, storage) and how to integrate external AI APIs and prompt engineering into your extension logic.
Chapter 1 (the WALKAROUND Method) covers extension architecture overview, Developer mode, unpacked extensions, and how to think of the browser as a programmable platform. You'll understand the mental model before writing any code.
Chapter 12 (the MULTIMETER Check) teaches extension-specific DevTools techniques, service worker debugging, error boundaries, graceful degradation, and performance profiling to ensure your extension runs smoothly at scale.
This course uses 13 proprietary frameworks (WALKAROUND, SCHEMATIC, SOLDER, FACEPLATE, WINGMAN, JUNCTION, PNEUMATIC, SILO, OUTLET, AXON, DOMINO, MULTIMETER, SHOPFRONT) that provide repeatable mental models for every aspect of extension development, from architecture to deployment.
No. You need basic JavaScript knowledge and familiarity with HTML/CSS. The course teaches extension-specific concepts from the ground up. We've had operations managers, junior developers, and full-stack engineers all succeed. If you can read and write JavaScript, you can build extensions.
The course is about 9 hours of learning — roughly 2 weeks at ~5 hours per week. All materials are available on-demand, so you can move faster or slower depending on your schedule.
Yes. Every framework in this course comes from real client work. The WALKAROUND Method, SCHEMATIC Protocol, SOLDER Method, and FACEPLATE Framework are all battle-tested. You'll build extensions that handle storage, communication, API integration, and analytics—the same challenges production extensions face.
You get access to our community forum where instructors and students help each other. We also provide working code for every chapter and real escalations from actual clients so you can see how problems get solved. Most questions get answered within 24 hours.
Absolutely. The frameworks and code are yours to use. You can build extensions for your own company or sell them to clients. The course teaches you how to handle licensing, permissions, and Chrome Web Store submission so you can ship professionally.
Yes. The certificate shows you've completed a rigorous, project-based curriculum. More importantly, you'll have 3-5 working extensions in your portfolio—that's what employers actually care about. You can link directly to your projects on GitHub and the Chrome Web Store.
The frameworks are architecture-agnostic. They teach you how to think about extension problems, not just how to code them. Chrome has evolved significantly, and the core concepts in this course remain solid. We update the course quarterly and notify all students of changes.
Yes. The frameworks translate directly. Firefox and Edge extensions use nearly identical architecture. Once you master Chrome, adapting to other browsers takes a few hours. We include a bonus module on cross-browser compatibility.