In case you missed it , here's what we built live, and how you can build it too.

On July 17 we went live on Jeff Fritz's channel for a hands-on AI workshop with a simple premise: let's learn about vibe coding and adding real AI features to real applications. An actual running build, keystroke by keystroke, container by container, red-test-to-green-test in front of a live audience.

Vibe coding gets thrown around as a punchline, but what happened in this session is the legit version of it: an AI agent doing the typing while a human stays firmly in the driver's seat, choosing the model, writing the skill, reading the stack trace, and deciding what done actually means. 

If you couldn't make it, here's the technical throughline.

1. Pick your model like it costs money because it does

The build opened inside GitHub Copilot, and the first real decision wasn't a line of code, it was which model. We walked through Copilot's model picker and, just as importantly, its pricing model: the difference between standby and usage-based pricing, and why the "just always use the biggest model" instinct is a good way to torch your budget.

In practice that meant reaching for Claude Sonnet 4.5 as the everyday workhorse and switching up to Claude Opus in thinking mode for the harder reasoning tasks including implementation planning, wiring up unfamiliar frameworks, and untangling the kind of error that only shows up at runtime. The lesson generalizes well beyond this stack: treat model selection as an engineering choice with a cost curve, not a default.

2. Teach your agent new tricks with Skills

This was the part of the workshop that made the room lean in. Instead of pasting the same instructions into chat over and over, Jeff used Agent Skills, the SKILL.md convention to give Copilot durable, reusable capabilities that live right in the repo under .github/skills.

We reviewed the SKILL.md syntax, then built a skill that teaches the agent how to add a new API endpoint the right way for this project: the routing, the conventions, the tests. Then we watched it work: the agent scaffolded a new weather endpoint, and the test suite went from 14 tests to a full green run at 23 passing. That's the difference between a chatbot that guesses and an agent that follows your playbook. A skill is version-controlled, reviewable, and shared across the team which is exactly what you want when the AI is touching production code.

3. Stand it up with .NET Aspire

With the codegen loop humming, we needed something to actually run. Enter .NET Aspire as the orchestration layer: dotnet add package for the integrations, aspire run to bring the whole thing up, and Aspire's app model to wire services together instead of hand-rolling connection strings and hoping. Aspire's job here is to make the multi-service app (API + data store + AI services) feel like one thing you can launch, inspect, and debug locally.

4. Give the app a memory: Redis vector storage + GitHub Models embeddings

Here's where AI feature started meaning retrieval-augmented generation. The scenario: a conference session assistant that can actually answer "which sessions are about AI or machine learning?" and "plan me a schedule for the AI talks."

To do that, the app needs a memory. We stood up Redis Stack as a vector store, using RediSearch for vector and full-text search, and generated embeddings with GitHub Models (text-embedding-3-small) so session content could be matched semantically rather than by keyword.

And because this was live this is where the real engineering showed up. Getting the Redis search module to load correctly meant working through container image tags, an invalid reference format here, a module-not-loading error there, and a restart to pull the right redis-stack image. We let the agent take a few swings, caught it when it started to hallucinate a fix, and steered it back. That loop, agent proposes, human verifies, both iterate is the actual craft of vibe coding, and it's a lot more honest than any demo where everything works on the first try.

5. From feature to agent: Microsoft Agent Framework + guardrails

Once retrieval worked, we wrapped it as a proper agent using the Microsoft Agent Framework, a session assistant with a system prompt, a factory to construct it, and plugins to give it tools. Then we did the fun part: pressure-testing the system prompt. A pirate accent here, a deliberately outlandish "make something up that's clearly false" instruction there, not for laughs (okay, partly for laughs), but to see how the system prompt shapes behavior and where guardrails do and don't hold. If you're shipping an agent, that intuition is required.

6. Don't fly blind: observability with OpenTelemetry

The last piece is really, really important. We instrumented the agent with OpenTelemetry; UseOpenTelemetry() on the builder, agent monitoring enabled, sensitive-data telemetry toggled on for the demo and piped it into an observability dashboard so you can actually see what the agent is doing: which model it called, what it retrieved, where the latency went. An AI feature you can't observe is an AI feature you can't operate.

The takeaway

Strung together, the session went from an empty editor to a running, observable, retrieval-backed AI agent using GitHub Copilot with Claude models, custom Skills, .NET Aspire, Redis vector storage, GitHub Models embeddings, the Microsoft Agent Framework, and OpenTelemetry. Any one of those is a blog post on its own. Watching them snap together in one live build is the thing worth a few hours of your afternoon.

More than the specific stack, the takeaway is the posture: let the agent do the heavy typing, but stay the engineer. Choose the model deliberately. Encode your conventions as Skills. Read the errors yourself. Instrument everything. That's not the death of engineering; it's engineering with a very fast, very literal pair partner. It's how you code smarter and ship faster, and it's the same discipline we bring to modernizing legacy applications at GAPVelocity AI every day.

Watch the replay

Couldn't join live? The full workshop is up now. Open your editor, and build along.

▶ Watch the Hands-On AI Workshop with Jeff Fritz

Want to see this same agentic approach applied to your legacy codebase instead of a conference schedule? That's exactly what VELO does. Come talk to us.