Get Really Good at AI–Powered Development

Bite-sized video tutorials, step‑by‑step exercises, and a community where we can keep refining techniques together.

The Vision

Limitless Creation

Software development has always been a trade-off between imagination and implementation. You have a vision, but you get stuck in the mud of configuration and syntax.

AI changes the physics of creation.

We don't view AI as a manager delegating tasks. We view it as a creative multiplier—a partner that allows you to explore ideas faster than you can type them.

Exploration

Pushing the Boundaries

The "expert" used to be the person who knew the limitations. The modern creator is the person who finds the possibilities.

Curiosity as the Engine

Use AI to explore every "what if" without friction.

The Right Tool for the Job

Seamlessly switch between visual design tools, CLI agents, and deep-thinking architects.

Multi-Modal Expression

Use sketches, screenshots, and voice to communicate your intent.

Integration

AI as the Bridge

The most powerful systems start as simple scripts. AI helps you bridge the gap between a "hacky script" and a "robust tool."

We teach you to build workflows that are adaptable and flexible, allowing you to iterate wildly on your own machine, then solidify those workflows into reliable tools that your whole team can use.

Compound Growth

The Self-Improving Workspace

In a traditional workflow, you solve the same problem ten times. In a Compound Growth workflow, you solve it once, and your environment remembers it forever.

Harvesting Intelligence

Learn to mine your agent conversations for reusable "Skills" and "Rules." Every successfully solved ticket becomes a template for the next one.

The Feedback Loop

We treat logs, errors, and debug sessions as high-value signals. By feeding this data back into your system, you create a self-correcting loop where your tools get more reliable the more you use them.

The Machine That Builds The Machine

We don't just build software; we build the system that builds the software. Every bug you fix, every preference you tweak, becomes part of your system's memory.

This turns your development process into an investment. Every day you work, your "interest" compounds, leaving you with a toolkit that is exponentially more powerful than when you started.

Why dev.build?

The tools will change. The principles won't. We don't teach you just how to use a specific version of Cursor or a specific model from OpenAI. We teach you the underlying patterns of AI-assisted engineering that apply to every tool in the ecosystem. Dev.build focuses on the enduring skills of the new era.

Tool Fluency

Knowing exactly when to reach for a CLI agent versus an IDE assistant.

System Design

Building scriptable environments that adapt to new tools as they emerge.

Workflow Architecture

Connecting isolated tools into a cohesive, automated pipeline.

What You'll Get

Use-Case Driven Strategy

Learn the "sweet spot" for every tool—when to use Gemini's massive context, when to use Claude's reasoning, and when to use a simple script.

Universal Techniques

Master the core concepts—Rules, Hooks, Skills, and Plans—that work across Claude Code, Cursor, and custom agents.

Adaptable Workflows

Build a personal toolkit that grows with you. The prompts, scripts, and configurations you create here are designed to be portable and resilient to change.

Orchestration Patterns

Discover how to make disparate tools talk to each other, turning your local environment into a unified creative engine.

Future-Proof Foundations

Focus on text-based configuration and open standards (like MCP) that ensure your workflow survives the next hype cycle.

Community-Driven Learning

Access a growing library of shared skills, prompts, and configurations from practitioners pushing the same boundaries.

Content Roadmap

The tools change weekly, but the principles of creative orchestration are timeless. This living curriculum evolves with the industry.

The CLI Backbone – Setting up GitHub CLI (gh) for agent-driven collaboration.
Safety Nets – Mastering Local History and undo trees to fearlessly experiment.
Visual Communication – Screenshot and annotation workflows for precise multi-modal context.
Terminal Multiplexing – Using tmux to keep multiple creative streams alive.
Clean Slate Protocols – Isolating environments to keep your creative space pristine.

Rethinking Development – Moving from "writing code" to "shaping software."
The Tooling Spectrum – CLI vs. IDE vs. Web. Choosing your canvas.
The Big Four Setup – Deep configuration for Cursor, Claude Code, Gemini, and Codex CLI.
Context is King – Understanding how to feed your agents the right inspiration.
Prompt Engineering for Engineers – Beyond "fix this" -> Co-creation patterns.

Deep Dive: Claude Code – Building custom Skills that extend your capabilities.
OpenAI & Gemini CLIs – Leveraging massive context windows for deep exploration.
Local Scripting – Wiring agents into zsh/bash functions for instant creative bursts.
The "Unix Philosophy" of AI – Chaining small, focused AI tools together to build complex systems.
Git Integration – Intelligent commit generation and history analysis to track your evolution.

Cursor & VS Code – Composer, "Tab" workflows, and local model management.
Google's Anti-Gravity IDE – Exploring the new frontier of cloud-native AI editing.
Flow State – Configuring your environment to reduce friction and latency.
Shortcuts & Macros – Binding AI actions to muscle memory.
Debugging with Agents – Turning error messages into learning opportunities.

Visual Intelligence – Using images and screenshots to drive development.
Chrome DevTools MCP – Connecting agents directly to the browser for pixel-perfect design.
Frontend Workflows – From v0.dev prototyping to production components.
Design Systems – Teaching agents to adhere to and evolve your visual language.

Personalized Power Tools – Using AI to write the scripts that configure your environment.
Background Workers – Running "heavy" refactors or test generation in the background.
Shared Context – Building team-wide memories and documentation vectors.
Scalable Patterns – How to roll out AI tools to a team of 10, 50, or 100.
Custom MCP Servers – Extending agent capabilities with Model Context Protocol.

Learning Outcomes

Develop a "tools-first" intuition for solving any coding problem.

Command the command line as a primary interface for creative exploration.

Build and share custom skills/tools that automate your unique workflow.

Architect systems where humans provide the vision and agents handle the implementation.

Leverage multi-modal inputs (images, browser context) for full-stack expression.

Your Instructor

John Lindquist

John Lindquist is a co‑founder of egghead.io and a pioneer in developer education. With a history of teaching through bite-sized, high-impact content, John has spent time since the advent of AI tools immersed in the bleeding edge of AI development tools.

From deep-diving into Cursor's internals to building custom MCP servers and maximizing Claude Code's potential, he is dedicated to mapping the territory of this new era and helping developers thrive in it.

Community & Ecosystem

Joining dev.build means plugging into a network of forward-thinking engineers.

Weekly Deep Dives

Exploring the latest releases (e.g., new Claude capabilities, Gemini updates).

Shared "Skills" Library

A repository of community-vetted prompts and agent configs.

Workflow Recipes

Copy-paste configurations for common development tasks.

Direct Access

To evolving best practices as we discover them together.

Join the Evolution

The industry is moving fast. Don't get stuck in the last generation of workflows.

Questions?

Have a specific workflow challenge or team training need? Contact me to discuss how we can help.

Let's build something amazing.