Press enter or click to view image in full size

Devin Chasanoff

It’s been about a day and a half since I returned from baby bonding leave, and my mind is already racing. Google has a generous leave policy, and I decided to truly unplug during that time to give my growing family my full attention. But as any developer knows, a “reset” often leads to a “rethink.”

The pace of innovation in this AI-driven world is, frankly, astonishing. One of the first things I noticed upon my return was the rise of agent skills. Essentially, these are folders of instructions, scripts, and resources that agents can discover and use to perform tasks more accurately and efficiently.

The Angular team recently released its own set of Angular agent skills (GitHub), and I just caught up on Addy Osmani’s agent-skills repository. His collection, which covers the entire software development lifecycle, recently went viral — and for good reason. Organizing skills in a cohesive way for agents to accomplish complex tasks brought me right back to a concept I was musing over before my leave: Agent Building Blocks. To understand my interest in this concept, let’s take a look at one of my favorite projects from last year.

The Experiment: The Angular AI Tutor

Last year, I created the Angular AI Tutor. The goal was to teach developers Angular interactively by guiding them step-by-step through building a modern application. You can access it now via the Angular MCP server.

The surprising part? Creating it wasn’t an uphill battle in terms of complexity. The instructions are open-sourced and written in plain English. It started as a simple experiment: Could I get Gemini to teach me Angular?

With a modest 10-line rules file, the answer was a resounding yes. Gemini didn’t just provide information; it created a learning journey that emphasized critical thinking and joy. But as I moved from “experiment” to “product,” I hit two major roadblocks:

  • Lesson Continuity: Creating a cohesive lesson plan where every step builds toward a single, navigable app.
  • Syntax Recency: Ensuring the agent used modern features (like Signals) that the model wasn’t originally trained on.

The Maintenance Nightmare

After some trial and error, I overcame these hurdles with a README that totaled 824 lines. Not bad for a functional tutor! The project sparked considerable interest — Angular GDEs wanted to build their own, and teams like Flutter and Firebase were curious about the “Tutor” model for their own ecosystems.

However, there was a problem that needed to be addressed first: The logic was too “coupled.”

Get Devin Chasanoff’s stories in your inbox

Join Medium for free to get updates from this writer.

Remember me for faster sign in

The instructions that controlled the tutor’s behavior were intertwined with Angular-specific syntax. This created a few headaches:

  1. Low Reusability: Retrofitting the tutor for Firebase or Flutter required a massive rewrite.
  2. Duplication: We had separate rules for the tutor and separate rules for general code generation.
  3. Update Friction: Adding a new module like Signal Forms was time-consuming because changes had to be made in multiple places.

My first attempt at a fix — breaking the language into multiple rules files — flopped. Without an agent routing mechanism, the model had trouble deciding which “skill” to pull from and when.

The Vision: Context Pipeline Engineering

In one of my last meetings before bonding leave, I proposed a Router + Building Blocks architecture. The idea was to break the AI tutor’s brain into modular components that could be reused or swapped for different frameworks. At the time, I wasn’t sure how to build it.

Now that I’m back, I see Agent Skills as the potential vehicle for this vision. But there are still some questions we need to explore:

  • Extensibility: How do we make these skills customizable for individual developer workflows?
  • Reliability: How do we keep the skills and their use by the model reliable in the presence of other skills, tools, and context used by the model?
  • Token Optimization: How do we keep building block pipelines up-to-date while ensuring they don’t bloat the model’s context window?
  • Stability: As models evolve, how do we ensure the “pipeline” doesn’t break?

I’ve started calling this discipline Context Pipeline Engineering. If you’re interested in these deeper, structural questions about AI engineering, I touched on some of these themes in my ng-conf talk: Architect or Assembler: Your Role in the AI Future.

It’s good to be back. Subscribe to our YouTube channel and blog to follow along as we explore these questions and more. Let’s build something.