Learn Chrome, Playwright and Rails

Vimium's Vomnibar is a "command palette"-like search tool for your open tabs, browser history, and bookmarks. We can search through and jump to any tab open across browser windows. We can also do a generalized search with results that also include browser history and bookmarks which can either be opened in the current tab or a new tab. If you're anything like me, you open tons of tabs and visit hundreds of webpages over the course of a week. The vomnibar puts all of that at your fingertips.

Josh Branchaud

Open Tabs, Browser History, and Bookmarks with the Vomnibar

Vimium's Vomnibar is a "command palette"-like search tool for your open tabs, browser history, and bookmarks.

Another aspect of Vimium's configurability is customizable key mappings. We can add new mappings and override existing ones. If there is a certain Vimium feature you want to make easier to trigger, adjust the key mapping to suit your needs.

Configure Custom Vimium Key Mappings

Another aspect of Vimium's configurability is customizable key mappings. We can add new mappings and override existing ones.

Many aspects of Vimium can be configured in order to bend the tool to your specific needs and use cases. We look at how to configure what sites turn off Vimium, the default search engine, link hint characters, and other basic settings. We also see how both insert mode and searching a visual selection work. Custom keymappings and custom search engines are covered in subsequent lessons.

Configure Basic Aspects of Vimium

Many aspects of Vimium can be configured in order to bend the tool to your specific needs and use cases.

Vimium's "marks" feature lets you mark positions in the current tab and across tabs. These are positional markers that you can jump back to. For instance, as you browse a huge page of documentation or a massive forum discussion, you can leave a series of "dog ears" to sections or conversations that you'll later want to revisit. Each tab supports its own set of lower-case letter marks. Upper-case letter marks are shared across tabs allowing you to seamlessly move between a specific set of tabs regardless of how they are arranged.

Set Marks on a Vimium Webpage You Want to Jump Back To

Vimium's "marks" feature lets you mark positions in the current tab and across tabs. These are positional markers that you can jump back to.

Vimium's `yy` shortcut makes quick work of grabbing the URL for the current page. I find this useful for linking to an article in my notes or sharing a web page with my team in Slack/Discord. We'll get a glimpse at a couple other features like `gi` (for "go to input") and `o` to open the URL on the clipboard.

Grab and Open URLs with Vimium

Vimium's `yy` shortcut makes quick work of grabbing the URL for the current page.

An introduction to "Why Use Vimium" and how to install it in your browser of choice. Though this entire course uses Chrome, Vimium is also available for Edge and Firefox. There is a lot that Vimium can do — on-page navigation, moving between tabs, interacting with links and other page elements, and much more. We'll get into all of that in the following lessons.

Install and Start Using Vimium

An introduction to "Why Use Vimium" and how to install it in your browser of choice

A powerful navigation and interaction feature, and probably my most used Vimium feature, is Link Hints. By hitting `f`, we prompt Vimium to overlay link hints for every visible link, button, and interactive HTML element (e.g. a text area). By typing the keys corresponding to a link hint, we effectively click that link or element. We also look at a few page movement commands like scrolling up (`k`) and down (`j`) as well as jumping to the top of a page (`gg`) and to the bottom (`G`). Putting all of these together, we can get into a fluid and efficient flow for common browser tasks.

Follow Links and Fill Forms with Vimium

A powerful navigation and interaction feature, and probably my most used Vimium feature, is Link Hints.

The Vimium Chrome extension enhances page navigation and searching. By pressing forward slash, users enter find mode to search terms on the page. Additional keys like 'N' and Shift+N help navigate through search results forwards and backwards, respectively. The extension proves especially useful on complex web pages, like Stack Overflow, for quickly locating specific sections like answers or share links without reading through all the content.


Navigate using find with Vimium

With these advanced URL manipulation commands we have a whole new way to think about traversing between locations on a website. This is especially useful for sites like GitHub that use a hierarchical URL structure. Since each layer of the URL is a valid page, we can move up that structure (with `gu`) and edit the current URL (with `ge`) to navigate somewhere else.

Traverse a Site with Advanced URL Manipulation with Vimium

With these advanced URL manipulation commands we have a whole new way to think about traversing between locations on a website.

Losing focus and getting lost while looking for that browser tab from *earlier* is a drag on getting things done. Even minor slow-downs in how you navigate within and between pages can pull you out of your flow. There are so many minor aspects of your browser-based workflows that chip away at your productivity.

Vimium extends how you use the browser with a highly-efficient, keyboard-centric workflow. Vimium leverages powerful concepts from the Vim editor (`j`/`k` for scrolling, `f` for following links, `/` for find, etc.) allowing for faster navigation and interaction without the need to switch to the mouse.

Don't worry, you don't need to know anything about Vim. Anyone who spends a lot of time in the browser and is willing to learn a few shortcuts has a lot to gain from using Vimium.

This course demonstrates the core features of Vimium through practical, real-world use cases. Even if you only adopt a few of the shortcuts, you'll find yourself using the browser in surprising, new, and speedy ways.

Get Started with Vimium

Playwright is a framework for reliable end-to-end testing of modern web apps.

playwright

Playwright provides a simple library that you can install via npm for automating various browser engines. That is what we demo in this lesson.

Playwright Library for Browser Automation

In this lesson we look at the Playwright Test concept of Fixtures. We demo the creation of various fixtures and explain the idea behind browser, context and page.

Playwright Test Fixtures, Browser Context and Page

In this lesson we demonstrate how you can create Page Objects in Playwright. The Page Object Model (lovingly called pom) is a great way to simplify your test code and make it more easy to understand and maintain in the long run.

Page Object Model Pattern with Playwright

In this lesson we look at various ways you can select different elements on page using Playwright Selectors. We also demo playwright selector engines and selector chaining

Playwright Selectors

A common post mortem debugging tool for e2e tests is screenshots and videos. These can be enabled via options in the Playwright config and that is what we demo in this lesson.

Capture Failed Test Videos and Screenshots with Playwright

Playwright provides a powerful tool in the form of the trace viewer to help you debug any issues in your test after they have failed. That is exactly what we demo in this lesson.

Postmortem Debugging Failed Tests with the Playwright Trace Viewer

In this lesson we introduce the codegen feature of Playwright which can be used to quickly generate automation / test code.

Quickly Generate Playwright Tests with Codegen

In this lesson we look at how you can use the playwright inspector to debug any issues in your tests. We run through a sample test and guide you through the various portions of the playwright inspector UI.

Debugging Playwright Tests with Inspector

GitHub fosters a fast, flexible, and collaborative development process that lets you work on your own or with others.

github

In this lesson we look at why you would need to generate snapshots on your CI server. We follow this up by creating a simple Github Action that will generate new snapshots against a pull request once you leave a specially formatted "slash command" style comment.

Generate Playwright Snapshots on your CI Server

In this lesson we look at how you can do simple VRT (visual regression testing) using Playwright tests.

Visual Regression Testing with Playwright

Visual Studio Code is an integrated development environment (IDE) built and maintained by Microsoft. It is offered free of charge.

vscode

We look at the various features of the VSCode Extension for Playwright and how it can help you with your testing workflow.

Playwright VSCode Extension

Hey Everyone 👋,

John Lindquist here with the third issue of AI Dev Essentials! Another week, another whirlwind of updates in the AI development space. We saw Google drop Gemini 2.5 Flash, OpenAI counter with o3/o4-mini and a new Codex CLI, Anthropic beef up Claude with research tools, and continued evolution in the MCP and agent framework landscape. Personally, I've been digging into Gemini 2.5 Flash – it's impressive to see Google pushing the performance frontier for smaller models and comparing it directly against the competition like O4-mini. Let's dive in!

___

### New egghead.io Lesson This Week:

* **[Generate and Debug MCP Servers from Scratch using GitHub Examples and AI](https://egghead.io/generate-and-debug-mcp-servers-from-scratch~k98ad):** Building complex components like Model Context Protocol (MCP) servers from scratch can be challenging, especially without good reference implementations. This lesson demonstrates a powerful workflow combining the `ghx` CLI tool (a wrapper I built for the GitHub CLI - find it [here](https://www.npmjs.com/package/@johnlindquist/ghx)) with AI assistants (like Google's AI Studio and Cursor's agent) to overcome this hurdle. Learn how to scrape real-world examples from GitHub using `ghx` ([see scraped examples here](https://gist.github.com/johnlindquist/b19673bbf6a396406dff869beecace1d)), feed them to an AI to generate a new server, and then integrate and debug it within Cursor. It's a practical look at bootstrapping complex tools using AI and targeted code searching.

___

Here are the highlights that caught my eye this past week:

## Model & Major Platform Updates

* **Gemini 2.5 Flash Arrives:** Google released Gemini 2.5 Flash ([Google Developers Blog](https://developers.googleblog.com/en/start-building-with-gemini-25-flash/)), their first unified reasoning model with thinking budgets. It's positioned as a high-performance, cost-effective option. Notably, Google's benchmarks included comparisons against OpenAI's very recent O4-mini, drawing praise for transparency ([Nathan Lambert](https://x.com/natolambert/status/1912958672881303943)). It's available via the Gemini API, AI Studio, Vertex, and the Gemini app. The [Live API docs](https://ai.google.dev/gemini-api/docs/live) are also updated.
* **OpenAI Counters with o3/o4-mini & Codex CLI:** OpenAI launched [o3 and o4-mini](https://openai.com/index/introducing-o3-and-o4-mini/), highlighting their agentic capabilities and tool use during Chain-of-Thought. Alongside these, they released the open-source [Codex CLI](https://github.com/openai/codex), a coding agent designed to leverage these new models. Interestingly, the OpenAI dev behind Codex CLI was spotted [using Cursor](https://x.com/chuhang1122/status/1912786904812294312).
* **Claude Gets Research Superpowers:** Anthropic rolled out a major [Claude upgrade](https://x.com/jowettbrendan/status/1912446262756151732) introducing a "Research" agent capability. It can search the web and internal docs, chain queries, and explore topics agentically, building citations along the way. They also added Google Workspace integration (Gmail, Calendar, Docs) for paid users. (Official blog post link pending confirmation).
* **Cursor 0.49 Update:** The latest Cursor update ([Changelog 0.49](https://www.cursor.com/changelog/0-49)) brings several enhancements: improved Cursor Rules generation and attachment, better chat history access, built-in diff reviews, image support in MCP context, agent command editing/skipping, global ignore files, added models (Gemini 2.5 Pro, Grok 3, GPT-4.1), and project structure context for the agent. [AGIdevice](https://x.com/agidevice/status/1913575514670776520) shows how to enable the beta features.

## Tooling & Protocol Developments

* **MCP Nuances:** David Cramer cautioned against simply [proxying OpenAPI specs via MCP](https://x.com/zeeg/status/1913289979368796671), arguing it misuses the protocol and ignores LLM limitations in tool selection and JSON handling.
* **MCP Transport Clarification:** Harald Kirschner clarified the newer "Streamable HTTP" transport ([MCP Spec](https://modelcontextprotocol.io/specification/2025-03-26/basic/transports)), noting it's primarily HTTP-based, with Server-Sent Events (SSE) as an optional upgrade for streaming server messages, deprecating the older standalone SSE transport. Discussions on implementation and future streaming enhancements are ongoing ([TS SDK Issue #220](https://github.com/modelcontextprotocol/typescript-sdk/issues/220), [MCP Roadmap](https://modelcontextprotocol.io/development/roadmap)).
* **Agent2Agent (A2A) Protocol Announced:** Google unveiled the Agent2Agent (A2A) protocol ([Google Developers Blog](https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/)), an open standard aiming to allow AI agents from different frameworks and vendors to communicate and collaborate. This is a significant step towards agent interoperability. Akshay Pachaar also provided a clear explanation contrasting [MCP vs. A2A](https://x.com/akshay_pachaar/status/1912123161883345321). ([GitHub Repo](https://github.com/google/A2A))
* **New MCP Tools:** Ishan Goswami released an open-source [Twitter MCP Tool using Exa](https://x.com/TheIshanGoswami/status/1914226695118168331) (GitHub: [exa-labs/exa-mcp-server](https://github.com/exa-labs/exa-mcp-server)) for searching tweets/profiles without the official API. Eyal Toledano shipped [TaskmasterAI v0.12](https://x.com/EyalToledano/status/1914084622918455572) with multi-PRD parsing, smarter breakdowns, and easier MCP setup, alongside a new [website](http://task-master.dev).
* **Cursor Workflows & Tips:** Ryo Lu shared [12 tips for using Cursor effectively](https://x.com/ryolu_/status/1914384195138511142), emphasizing clear rules, specific prompts, and iterative testing. Prajwal Tomar detailed his ["Context Boundary Method"](https://x.com/PrajwalTomar_/status/1913961327711633601) using structured docs (PRD, Flow, Tech Stack etc.) to guide AI coding tools like Cursor and reduce errors. Andrew Jefferson noted potential issues with [Markdown tab completion](https://x.com/EastlondonDev/status/1913967886521053688) in Cursor.
* **AI UI Builders Compared:** Damien shared a comparison of [Replit, Bolt.new, Lovable.dev, and v0](https://x.com/damienghader/status/1913248328302608482) for generating a multi-step onboarding flow from the same prompt.

## Building AI Agents: Frameworks & Best Practices

* **Agent Framework Discussion:** Harrison Chase (LangChain) published a deep dive on [how to think about agent frameworks](https://blog.langchain.dev/how-to-think-about-agent-frameworks/), sparking discussion comparing approaches (agents vs. workflows, declarative vs. non-declarative) and frameworks like LangGraph, OpenAI's Agents SDK, CrewAI, and AutoGen. Key themes include balancing flexibility vs. predictability and choosing the right abstraction level. OpenAI also released its own [practical guide to building agents](https://cdn.openai.com/business-guides-and-resources/a-practical-guide-to-building-agents.pdf).
* **Production Agent Principles:** Dex Horthy shared principles for production-grade LLM apps in ["12-factor-Agents"](https://github.com/humanlayer/12-factor-agents), arguing successful systems often use focused LLM loops within well-engineered software rather than fully autonomous, monolithic agents. This resonated with many builders facing reliability challenges.
* **Agent Memory:** Taranjeet from [mem0.ai](https://x.com/taranjeetio/status/1912185506559053855) emphasized the importance of persistent memory (beyond session history) for truly intelligent agents that learn and adapt over time ([Blog Post](https://mem0.ai/blog/memory-in-agents-what-why-and-how/)).
* **Key Best Practices:** Common advice emerging from various discussions includes: start simple (maybe not even an agent), use structured outputs (like JSON schemas) to reduce hallucinations, prefer multiple specialized agents over one complex agent, own your control flow rather than relying solely on the framework, and carefully manage context windows. ([Anthropic Guide](https://www.anthropic.com/research/building-effective-agents), [Dev.to Summary](https://dev.to/isaachagoel/read-this-before-building-ai-agents-lessons-from-the-trenches-333i)).

___

**✨ Workshop Spotlight: Conquer the Complexity of Cursor ✨**

Master practical AI development workflows in Cursor. This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures.

* **When:** **This Thursday!** April 24, 2025, **9:00 AM - 2:00 PM (PDT)**
* **Where:** Zoom (Live Q&A included)
* **Investment:** $249

Unlock Cursor's potential and streamline your development process.

➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor) ➡️ [**Register Now ($249)**](https://buy.stripe.com/9AQaG5ftF5P22eAfZ3)

_(Team training also available)_

___

## Notable Prompts

* **o3 Fact-Checking:** A prompt structure for using o3 to thoroughly fact-check an entire article by parsing individual facts. (See [Matt Shumer's Tweet](https://x.com/mattshumer_/status/1914412812891570199) for the prompt start).
* **Multiple Experts Method:** A system prompt that instructs the AI to analyze problems from multiple expert perspectives (e.g., Systems Thinker, Risk Assessor) and synthesize their insights. (See [God of Prompt's Tweet](https://x.com/godofprompt/status/1914370848032497906) for the full prompt and example).
* **Personality-Infused Prompt:** A detailed persona prompt instructing the AI to adopt a specific, informal, and slightly critical tone using modern slang and abbreviations. (See [Kitze's Tweet](https://x.com/thekitze/status/1913719205007937825) for the full prompt, originally from [@threepointone](https://x.com/threepointone)).

## Community Buzz & Resources

* **New Community Site:** [AGIdevice](https://x.com/agidevice/status/1913666033870647325) is building [cursorcommunity.com](http://cursorcommunity.com) in public.
* **Industry Chatter:** Deirdre Bosa discussed the potential [OpenAI bid for Windsurf](https://x.com/dee_bosa/status/1912906057791447294) and the shift towards the app layer. AI Native Dev reported on perceived [friction between Microsoft and Cursor](https://x.com/ainativedev/status/1912869556973949430) ([Article](http://ainativedev.co/spx)).
* **Android XR Demo:** Google showed off prototype smart glasses with Android XR ([Demo Video via 9to5Google](https://9to5google.com/2025/04/17/google-android-xr-smart-glasses-live-demo/)).
* **New Open Dialogue Model:** A new small open model, [Dia-1.6B](https://x.com/altryne/status/1914421817139454341), was released. It's focused on dialogue disentanglement – figuring out who's talking to whom in complex conversations. ([GitHub](https://github.com/nari-labs/dia), [Hugging Face](https://huggingface.co/nari-labs/Dia-1.6B)). I was extremely impressed with the demos – definitely worth checking out.
* **Video Generation with Veo 2:** Google's Veo 2 video generation model is now available in Gemini Advanced and Google AI Studio ([Google Blog](https://blog.google/products/gemini/video-generation/), [Developers Blog](https://developers.googleblog.com/en/veo-2-video-generation-now-generally-available/)). I've tried out a few videos and was really impressed with the quality. Pro tip: In AI Studio, you can use an image as a reference when generating video ([API Docs](https://ai.google.dev/gemini-api/docs/video#generate_from_images)), though surprisingly, Gemini doesn't support that yet. It's heavily rate-limited at the moment, but still fun to play with for generating short 8-second clips.

___

That’s the scoop for this issue! The pace isn't slowing down, particularly around agent capabilities, specialized models, and the tooling ecosystem supporting them.

If you have any feedback or questions, hit reply! Always happy to chat about the latest in AI dev tools.

John Lindquist


John Lindquist

AI Dev Essentials #3: Gemini Flash, o4-mini, Codex CLI, A2A Protocol & Agent Updates

AI Dev Essentials covers Gemini 2.5, O4-mini, Claude’s research tools, Codex CLI, and new workflows for building AI agents with MCP and Cursor.

Establish an automated, AI-driven workflow for implementing UI designs by comparing live development versions against target screenshots. This lesson integrates the Playwright MCP server for browser automation, a custom script using Pixelmatch for visual diffing, and Cursor Rules for persistent context. See how to instruct the Cursor Agent to iteratively implement design changes based on visual diff feedback, creating a robust loop where the AI refines the UI towards the target design.

**Workflow demonstrated in this lesson:**

*   Configure the Playwright MCP server within Cursor for browser control.
*   Use the Agent and Playwright MCP tools (`browser_navigate`, `browser_resize`, `browser_take_screenshot`) to capture baseline and current state PNG screenshots.
*   Install `pixelmatch` and `pngjs` dependencies.
*   Guide the Agent to create and run a TypeScript script (`compare-images.ts`) to generate visual diff images between screenshots.
*   Establish Cursor Rules (`visual-testing.mdc`, `project-setup.mdc`, etc.) to provide the Agent with necessary context about directories, scripts, dependencies, and the overall workflow.
*   Initiate an AI-driven design implementation loop:
    *   Agent captures the current state via Playwright.
    *   Agent runs the comparison script to get a visual diff.
    *   Agent analyzes the diff and implements code changes in the project (e.g., `app/page.tsx`, components, `globals.css`).
    *   Repeat the capture-compare-implement cycle, using the latest diff as feedback.
*   Use context files and prompts like "Please continue" to manage the multi-step process and guide the AI through potential interruptions.

**Key benefits:**

*   Creates an iterative, AI-driven workflow for implementing designs based on visual comparisons.
*   Combines browser automation (Playwright) and pixel-level diffing (Pixelmatch) within the Cursor environment.
*   Utilizes Cursor Rules to effectively manage context and guide the AI through complex, multi-step tasks.
*   Demonstrates how visual diffs can serve as direct feedback for AI-driven UI code generation and refinement.

AI-Driven Design Workflow: Playwright MCP Screenshots, Visual Diffs, and Cursor Rules

[Scraped MCP Examples](https://gist.github.com/johnlindquist/b19673bbf6a396406dff869beecace1d)
[ghx tool](https://www.npmjs.com/package/@johnlindquist/ghx)

Building complex components like Model Context Protocol (MCP) servers from scratch can be challenging, especially without good reference implementations. This lesson demonstrates a powerful workflow combining the `ghx` CLI tool with AI assistants (like Google's AI Studio and Cursor's agent) to overcome this hurdle.

You'll learn how to:

1.  **Use `ghx`:** Leverage the `ghx` command-line tool (which wraps the GitHub CLI) to search GitHub for real-world code examples based on specific import paths (e.g., `modelcontextprotocol/sdk/server/mcp.js`).
2.  **Refine Search Results:** Use `ghx` options (`--help`, `--limit`, `--max-filename`, `NOT demo`) within Cursor's chat to filter results, exclude simple demos, and gather a rich set of relevant MCP server implementations.
3.  **Provide AI Context:** Copy the aggregated code examples found by `ghx` into an AI environment like Google AI Studio (or ChatGPT).
4.  **Handle Context Limits:** See techniques for trimming large context files (like using Cursor's `Cmd+K` inline edit with `head -n` commands) to fit within model limits while retaining valuable examples.
5.  **Generate Code:** Prompt the AI (Gemini 2.5 Pro in AI Studio or ChatGPT O3) to generate a *new* MCP server (e.g., with five distinct tools) based *solely* on the provided real-world examples.
6.  **Integrate and Debug:** Set up the generated TypeScript code (`mcp_server.ts`) locally in Cursor, install dependencies (`pnpm install`), and use Cursor's agent (`Cmd+I`) or inline fixes (`Cmd+K`) to resolve TypeScript errors and path issues.
7.  **Configure in Cursor:** Add the newly created MCP server (running via `bun mcp_server.ts`) to Cursor's MCP settings, using the absolute path and the `bun` command.
8.  **Test the MCP Server:** Interact with Cursor's chat agent to call the custom tools (e.g., `add_note`, `list_notes`, `write_managed_file`) defined in the AI-generated MCP server, verifying its functionality.

This lesson showcases how combining targeted code searching (`ghx`) with the generative power of AI, fueled by relevant examples, can dramatically accelerate the process of building and bootstrapping complex tools and applications.

Generate and Debug MCP Servers from Scratch

Hey Everyone 👋,

John Lindquist here with the second issue of AI Dev Essentials! It's been another busy week in the AI tooling world. The biggest splash was probably GPT-4.1 hitting the streets, but there's plenty more action around MCP, Vercel's v0, Google's developer tools, and interesting community discussions. I've spent some time with GPT-4.1 already (specifically in Cursor), and while it shows promise, it didn't quite convince me to switch from Gemini 2.5 Pro yet. It stumbled on a few basic requests where Gemini usually shines on the first attempt.

---

### New egghead.io Lesson This Week:

* **[Create a Custom MCP that Calls Cursor Tools](https://egghead.io/create-a-custom-mcp-that-calls-cursor-tools~r77sw):** Learn how to build custom MCP server tools that allow Cursor's AI Agent to access your local project context. This lesson shows how to use Zod schemas and the crucial `.describe()` method to explicitly request information (like Git status or version) from the Cursor environment *before* your tool runs, enabling powerful, context-aware automation.

---

Here are the highlights that caught my eye this past week.

## Model Mania: GPT-4.1 Arrives, Plus Grok & Llama Updates

* **GPT-4.1 Lands:** OpenAI announced GPT-4.1, and it quickly became available via the [API](https://openai.com/live/) and showed up in [Cursor](https://x.com/cursor_ai/status/1911835651810738406). Cursor is offering it free for now to let users get a feel for it, though they don't recommend it as a default just yet. Curious to hear initial impressions from folks testing it out for coding tasks.

* **Grok 3 in Cursor:** Following other model additions, [Cursor also enabled Grok 3 models](https://x.com/amanrsanger/status/1910434915419906141), with the mini version available for free users. Aman Sanger noted it seems to "think upfront more than other models."

* **Community Hack: Llama 4.0 via Groq in Cursor:** Levi Dan shared a [detailed (and slightly hacky) guide](https://x.com/lxvi_brg/status/1908865544721154455) on how to wire up Groq's fast Llama 4.0 API into Cursor by using the OpenAI API key slot and intercepting requests. A clever workaround for the adventurous!

## Tooling & Platform Pulse

Lots of movement across different platforms and tools this week:

* **Vercel Ecosystem:**

  * Guillermo Rauch teased [v0 coming to VS Code](https://x.com/rauchg/status/1911524154458984515), hinting at tighter integration for the UI generation tool.

  * v0 also [added AI integrations](https://x.com/v0/status/1911912183149256943) with models from xai (Grok), FAL, Groq, and DeepInfra, including automatic API key setup and pay-as-you-go billing via Vercel Marketplace. They're offering a $10 credit for the Grok free tier.

  * Vercel shared insights on the [grep.app migration from CRA to Next.js](http://grep.app/), showcasing performance improvements. ([Source](https://x.com/rauchg/status/1911920410020757881)) I'm personally excited about this one – I rely heavily on examples when working with AI, and for me, a good example is often worth ten prompts. Tools like `grep.app` that make code discovery easier are invaluable.

* **Google's Growing Stack:**

  * Project IDX has officially become [Firebase Studio](https://x.com/_davideast/status/1909990728593453455), positioning itself as a cloud-based, agentic dev environment for full-stack AI apps, deeply integrated with Firebase. I've tried spinning up a few sites with it, and the speed is impressive. However, for more complex tasks like designing from images or intricate interactions, I still find myself leaning towards v0 for now.

  * Google quietly released the [Agent Development Kit (ADK)](https://x.com/omarsar0/status/1910004370864742757), a Python library (`pip install google-adk`) for building multi-agent systems with features like state management, tool usage, and orchestration. I haven't had a chance to dive into this yet, but it's right at the top of my list. Building robust agent systems is a huge area of interest, so this is probably the announcement I'm most excited about exploring this week.

  * Ramón Medrano Llamas shared his experience [moving back to VS Code from Cursor](https://x.com/rmedranollamas/status/1909516749612999149), highlighting the effectiveness of GitHub Copilot combined with the Gemini Code Assist extension (using Gemini 2.5 Pro in Agent Mode). I gave the Gemini Code Assist extension a try myself, but as someone deeply embedded in the Cursor workflow with established keyboard shortcuts and patterns, I struggled to find a flow I liked and didn't stick with it for long. It's interesting to see different perspectives, though!

  * AI features are rolling out more broadly in [Chrome](https://x.com/iam_chonchol/status/1909942954686636224), including text grabbing from YouTube videos and Google Lens integration.

* **Cloudflare Corner:**

  * Big news for edge compute: [Cloudflare Containers are coming to Open Beta in June](https://x.com/CherryJimbo/status/1910682562499850405), enabling running containerized apps (Next.js, Go, PHP confirmed) directly on the edge. This is huge news, in my opinion. Think about all the WordPress sites and other applications that rely on containerization. Opening this up on the edge unlocks incredible possibilities, including for AI applications. I'm super hyped to see what people build with this come June.

  * A new tool, [MCPify.ai](http://mcpify.ai/), launched for building MCP servers conversationally, built entirely on Cloudflare Workers and Durable Objects. ([Source](https://x.com/pbteja1998/status/1911723180445610149))

  * Securing MCP servers is getting easier, with examples shared using [WorkOS AuthKit](https://x.com/WorkOS/status/1910722639036874943) and [Auth0](https://x.com/dschenkelman/status/1910693265566728319).

* **IDE Updates:**

  * JetBrains shared the public [WebStorm roadmap for March-April](https://youtrack.jetbrains.com/issue/WEB-72310). ([Source](https://x.com/WebStormIDE/status/1909291367504748937))

> **✨ Workshop Spotlight: Conquer the Complexity of Cursor (Europe Friendly Time!) ✨**
>
> Missed the last workshop or found the timing tricky? This one's for you! Master practical AI development workflows in Cursor in a session scheduled for **12:00 PM UTC** to better accommodate European attendees.
>
> This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures. Unlock Cursor's potential and streamline your development process.
>
> * **When:** \[Check website for upcoming dates - This session is Europe-friendly at 12:00 PM UTC\]
>
> * **Where:** Zoom (Live Q&A included)
>
> * **Investment:** $149
>
> ➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor)
> ➡️ [**Register Now ($149)**](https://buy.stripe.com/7sI7tT81dfpC06s28c)
>
> *(Team training also available)*

## Community Buzz & Resources

* **MCP Explained:** Kent C. Dodds wrote a piece explaining [why he's excited about Model Context Protocol (MCP)](https://www.epicai.pro/the-game-changing-potential-of-model-context-protocol) and its potential. ([Source](https://x.com/kentcdodds/status/1911840456432034112))

* **Prompting Guide:** Ian Nuttall surfaced [v7 of Google's Prompt Engineering Guide](https://x.com/iannuttall/status/1911086164196606314), a deep dive into techniques and best practices. Definitely worth a look.

* **Discussion Starter:** Eric Zakariasson asked the community about their [favorite CLIs and MCP servers to use with the Cursor agent](https://x.com/ericzakariasson/status/1910808935961088346). What are you all using?

* **Gemini 2.5 Pro Praise:** The positive buzz around Gemini 2.5 Pro continues to grow in the community. It's getting rave reviews and even achieving 'S-tier' status on social platforms like Reddit for its coding capabilities. ([Source](https://x.com/suchenzang/status/1911251230317490416))

That’s a wrap for this week! There's always so much happening, it's hard to keep up, but hopefully, this helps surface some of the more interesting bits for developers working with AI.

If you have any feedback or questions, feel free to respond to this email. Always happy to talk shop about the latest AI tools.

John Lindquist

[egghead.io](https://egghead.io)

AI Dev Essentials #2: GPT-4.1 Arrives, MCP Deep Dive & Google's Agent Dev Kit

AI Dev Essentials #2: GPT-4.1 & Gemini updates, MCP tools, Vercel v0, Google ADK, Cloudflare Containers news. Latest AI dev tooling highlights.

In this quick walkthrough, you’ll learn how to drop Nx into an existing npm or pnpm workspace and immediately benefit from project graph visualization, caching, and smart task orchestration, all without rewriting your setup.

You’ll start with a standard React monorepo containing a Vite app, a UI package, and utility functions. Then, using a single command (`nx init`), you’ll initialize Nx and see how it auto-detects your existing scripts, builds a dependency graph, and enables advanced features like affected commands and local caching.

We're also going to explore optional enhancements using Nx plugins for Vite and React. You’ll see how they help Nx infer tasks directly from your Vite config files, improve DX with the Nx Console VS Code extension, and leverage Nx plugin generators to scaffold code with a consistent structure.

What you’ll learn
- How to initialize Nx in an existing npm or pnpm monorepo
- How Nx understands your workspace structure and scripts
- How local caching and affected builds speed up development
- How optional Nx plugins improve DX without adding bloat
- How to scaffold new packages

Using Nx on an existing React and NPM workspace based monorepo

Applying Nx to an existing React monorepo to enable caching, task orchestration, and project graph analysis without changing your current setup.

Typing repetitive or complex instructions for Cursor's AI agent can slow down your workflow. This lesson teaches you how to create custom slash commands (e.g., `/s term`, `/l`, `/c`) using Cursor's "Rules" feature. Learn how to map these simple shortcuts to specific AI actions, instructing the agent to use precise tools like `codebase_search`, `edit_file`, or `run_terminal_cmd` based on your command and the current conversation context.

**Workflow demonstrated in this lesson:**

*   List available AI tools (built-in and MCP) to get their exact names.
*   Navigate to Cursor Settings -> Rules.
*   Define custom rules under a heading (e.g., `## Slash Commands`).
*   Create rules mapping a slash command pattern (like `/s <term>`) to a detailed instruction specifying which tool to use and how (e.g., "Use the codebase_search tool to search for <term/>").
*   Define rules that leverage conversation context (e.g., for summarizing notes or creating commit messages).
*   Save the rules (potentially in `.cursor/rules/project.mdc` for team sharing).
*   Invoke the custom slash commands (e.g., `/s handle`, `/l`, `/c`) in the chat/agent window.
*   Observe the AI understanding the shortcut and executing the intended tool call.

**Key benefits:**

*   Creates efficient, reusable shortcuts for common AI interactions.
*   Reduces the need for typing lengthy, detailed prompts repeatedly.
*   Allows mapping simple commands to specific Cursor tool invocations.
*   Enables commands that leverage the ongoing conversation context.
*   Improves workflow speed and consistency when working with the AI agent.

Speed Up Your Agents with Cursor Slash Commands

Hey Everyone 👋,

John Lindquist here. Since I've been diving deep into AI tooling and workflows over the past year, I'm starting this weekly newsletter to share updates on what interests me and could be helpful to the community. The goal is to help everyone stay up-to-date with the latest in essentials tools for AI devs.

I'll focus on relevant community news, model evaluations for coding, notable tools like Cursor and Windsurf, and practical workflows (including tools I build myself 😇). This week kicks off Cloudflare Developer Week with major announcements around agent/MCP services that many of us will likely use soon (I'll dig in and share my thoughts next issue). There are also lots of hints about new coding models possibly coming to Cursor (though my preference remains Gemini 2.5). Personally, I'm hoping for a Gemini Flash 2.5 variant. So let's hop into the latest! For my detailed, up-to-date workflows, check out the workshop info below.

Recent egghead.io lessons about AI tooling:

* **[Swarm Intelligence: Massively Parallelize Your AI Agents in Cursor](https://egghead.io/swarm-intelligence-massively-parallelize-your-ai-agents-in-cursor~g7u2g):** A workflow using `file-forge`, AI scripting, and a custom `git worktree` tool (`wt`) to launch parallel Cursor agents on different branches.
* **[Build a Better Edit Tool in Cursor with Custom Agent Modes](https://egghead.io/build-a-better-edit-tool-in-cursor-with-custom-agent-modes~21rr0):** Create a focused 'edit mode' in Cursor for precise AI refactors without conversational overhead, overcoming Command-K limitations.
* **[Visually Clone Websites with Gemini 2.5 Canvas for Cursor](https://egghead.io/visually-clone-websites-with-gemini-2-5-canvas-for-cursor~s5ugk):** Use Gemini 2.5 Pro's Canvas feature within Cursor to analyze and replicate website structures.

---

## Cloudflare Developer Week: Agent & Platform Updates

Cloudflare announced several updates relevant to AI application development:

* **Durable Objects Free Tier:** Lowers the barrier for experimenting with stateful serverless and the Agents SDK. ([Rita Kozlov](https://x.com/ritakozlov_/status/1909231625855983939))
* **MCP Enhancements:** BYO Auth (incl. [Auth0](https://x.com/auth0/status/1909307220816228354)) and Hibernation for MCP servers aim to improve agent security and efficiency. Exercise caution with MCP, but these are steps toward production viability.
* **Workflows GA & autoRAG:** Orchestration tool is now GA; a new autoRAG product indicates more integrated AI solutions.
* **Outerbase Acquisition:** Expect Durable Objects usability improvements following this acquisition. ([Rita Kozlov](https://x.com/ritakozlov_/status/1909232149246492887))
* **OpenNext Adapter Beta:** v1.0-beta for deploying Next.js apps on Cloudflare Pages adds caching, PPR, middleware support. ([CloudflareDev](https://x.com/CloudflareDev/status/1909598450871652398))

**Summary:** Cloudflare is actively enhancing its platform for AI/agent development, particularly reducing friction with Durable Objects and MCP.

## Llama 4 & Nemotron-Ultra Released

Meta's Llama 4 models began rolling out, with initial reports of variable quality across implementations. Meta attributes this to implementation stabilization, denying training on test sets ([Ahmad Al-Dahle](https://x.com/Ahmad_Al_Dahle/status/1909302532306092107)). Nvidia subsequently released **Llama-Nemotron-Ultra** (253B parameters), derived from Llama-405B via pruning and reasoning-focused post-training. Open weights and data are available ([Oleksii Kuchaiev](https://x.com/kuchaev/status/1909444566379573646)).

**Summary:** More powerful open models are available. Llama 4's initial rollout highlights the importance of stable implementations. Nemotron-Ultra adds a high-end specialized option.

---

## Quasar Alpha: Stealth Model on OpenRouter

OpenRouter provides early access to "Quasar Alpha," a model with limited public details but notable claims: 1M token context, benchmarks reportedly surpassing Claude 3.7 Sonnet, and >4x faster speeds. Reports suggest strong coding performance comparable to O3 Mini/DeepSeek R1 but significantly faster ([Matthew Berman's Thread](https://x.com/TheMattBerman/status/1908286423976886371)). The originating lab remains anonymous; speculation includes GPT-5, Claude 4, or Gemini 3.

**Summary:** The combination of large context, speed, and reported coding strength warrants attention for agentic workflows and large codebase analysis, despite benchmark caveats. Worth testing via OpenRouter if accessible.

---

**✨ Workshop Spotlight: Conquer the Complexity of Cursor ✨**

Master practical AI development workflows in Cursor. This hands-on workshop covers Agents, Ask, Custom Modes, multi-file analysis, effective prompting, Cursor rules, and strategies for handling AI failures.

* **When:** **This Thursday!** April 10, 2025, 9:00 AM - 2:00 PM (PDT)
* **Where:** Zoom (Live Q&A included)
* **Investment:** $149

Unlock Cursor's potential and streamline your development process.

➡️ [**Read More about the Workshop**](https://egghead.io/workshop/cursor)
➡️ [**Register Now ($149)**](https://buy.stripe.com/dR67tT4P17Xa8CYfZ1)

*(Team training also available)*

---

## Quick Links

* **Nightwhisper Buzz:** Highly-rated coding model "Nightwhisper" (rumored Gemini 2.5 variant?) left LMSys Arena; release may be imminent. ([ʟᴇɢɪᴛ Tweet](https://x.com/legit_api/status/1908264443827351913), [AiBattle Tweet](https://x.com/AiBattle_/status/1907519430961025476))
* **AI SDK Speech-to-Text:** Vercel AI SDK added a `transcribe` function. ([AI SDK Tweet](https://x.com/aisdk/status/1909603418639155460))
* **Gemini 2.5 Pro Updates:** Supports YouTube URLs as input in AI Studio (transcribe, summarize, analyze); reported improvements reducing stop issues/displaying thinking tokens. ([Jean Gatt Tweet](https://x.com/jean__gatt/status/1909256747518226829), [Eric Zakariasson Tweet](https://x.com/ericzakariasson/status/1908619515023548880))
* **Baby Cursor Project:** Cursor's Ryo Lu is building a rapid prototyping environment for IDE ideas. ([Ryo Lu Tweet](https://x.com/ryolu_/status/1908328050154233863))
* **(Rumor) Qwen3 Soon?:** Hints suggest Alibaba's Qwen3 model release is near. ([Elaina Tweet](https://x.com/Elaina43114880/status/1909572798944841859))

---

If you have any feedback or any questions, feel free to respond to this email. Always happy to talk shop about the latest AI tools.

John Lindquist

[egghead.io](https://egghead.io)

AI Dev Essentials #1: Cloudflare agent updates, Llama 4/Nemotron/Quasar models, Cursor workshop

Cursor's AI Agent has the abilitly to invoke MCP tools, but they lack direct access to your project. This lesson shows how to build custom MCP (Model Context Protocol) server tools that bridge this gap. Learn to define tool parameters using Zod schemas and the crucial `.describe()` method to explicitly request necessary context from the Cursor environment *before* your tool runs. See how the AI gathers this information (like Git status or version via terminal commands, or web search results) and passes it to your tool, enabling powerful, context-aware automation.

**Workflow demonstrated in this lesson:**

*   Scaffold a basic MCP server using a Cloudflare template (`pnpm create cloudflare`).
*   Run the MCP server locally and configure it in Cursor settings.
*   Define MCP tools (e.g., `status`) within the server code (`index.ts`).
*   Specify required context for tools using Zod schema parameters and `.describe()` (e.g., requesting "The status of the git repository").
*   Interact with the Cursor Agent using natural language (e.g., "Please check the status").
*   Observe the Agent's thought process: identifying the need for specific context based on the `.describe()` text.
*   See the Agent automatically using its *own* tools (like `run_terminal_cmd` or `web_search`) to gather the requested context *before* calling your MCP tool.
*   Watch the Agent call your MCP tool, passing the gathered local context (Git status, version, etc.) as arguments.
*   Receive the final response from the Agent, incorporating the information provided by your local MCP tool.

**Key benefits:**

*   Allows Cursor's AI to access and reason about information from your local machine (Git status, versions, file contents, etc.).
*   Enables the creation of AI tools that directly interact with or report on your local development environment.
*   Demonstrates the power of using `.describe()` in Zod schemas to guide the AI in gathering necessary context automatically.
*   Unlocks advanced automation possibilities by combining AI reasoning with local machine access.