A 2-Day Technical Workshop · Technovate Hub
GITS, Udaipur · June 18–19, 2026
AICTE Indovation Centre, Jaipur
Right now, you can ask an AI to write code.
By 5 PM tomorrow you'll have built the system that decides what an AI writes — an MCP server an agent calls, a pipeline you broke on purpose and then hardened, and a spec-driven app, shipped live.
The engineer who uses AI and the one who architects it are not the same person.
This is the room where you cross over.
You will learn the difference between building with AI and building AI systems.
By the end, you won't just use an agent. You'll have built one — and shipped it live.
Three words. Each one is a promise.
Agentic — AI that acts, not just talks. It perceives, decides, acts, and remembers — in a loop.
Architect — not a coder, not a prompter. You design the system: its rules, its limits, what it's allowed to do.
The title is the thesis: Design autonomous systems — don't just use them.
This is the line everything else hangs on.
What most people already do:
The intelligence is rented — one prompt at a time.
What this workshop teaches:
The system runs, self-corrects, and deploys — you supervise the architecture.
Building with AI: you hold the AI and do the work. Building AI systems: you build the thing that holds the AI — and it does the work.
Building with AI: you hold the AI and do the work.
Building AI systems: you build the thing that holds the AI — and it does the work.
Using AI = driving the car.
Building AI systems = engineering the self-driving stack:
No prior agent experience assumed — JS/TS + Git is enough. If you want the right-hand column, you're in the right room.
Day 1 — The Mechanism How an agent works. Take apart the agent loop; build the MCP harness that lets AI safely touch real systems.
Day 2 — The Method How to direct it well. Stop coding line-by-line; write machine-readable specs (BMAD) that drive an agent across the IDE, terminal, browser, and cloud.
Day 1 gives the agent hands. Day 2 gives it marching orders.
A single English sentence —
flows through the system you built, securely updates your data layer, and renders live on a production URL.
That's the proof: you didn't use a system. You built one.
A secure, auditable full-stack developer journal.
You build it. The agent helps. You stay the architect.
Four things (the setup-check script verifies them):
setup-check
npm
npx
agy
uv
uvx
mock-search
Not sure? Run the setup-check script (course site → Resources) — it checks all of this in ~10 seconds and installs what it can.
The public nomination mentioned VS Code, Claude Desktop, Copilot, Ollama, and cloud accounts. You don't need them here: the host is Antigravity (a VS Code fork), search is DuckDuckGo / mock-search, and the Day-2 app runs locally (:3000 / :3001).
:3000
:3001
Timing — reporting 09:00; sessions 09:30–17:00 both days; morning, lunch, and afternoon breaks (see the At-a-Glance slides).
Wi-Fi — connect now; it can wobble mid-lab. Every lab has an offline fallback (e.g. mock-search), so the network never blocks you.
The lab social contract
Three questions frame the entire workshop:
WHY → Principles The beliefs that decide what good looks like.
WHAT → Framework The structure those principles take shape in.
HOW → Process + Methods + Tools The concrete way we execute it, day to day.
Most courses teach only the How. We start with Why, so the How makes sense.
If you forget every command and config from these two days, keep these.
A system you can't predict is a system you can't trust.
If you can't say what the system will do before it runs, you haven't designed it yet.
Your value moves up the stack.
Promotion, not replacement: from coder → architect.
Once you stop typing every line, directing the agent splits into two modes:
The orchestrator's skill set: specify · decompose · evaluate · design the constraints. The better your spec, the more you can safely orchestrate.
An agent that can do anything is a liability, not a feature.
Power without boundaries isn't autonomy — it's risk.
The spec is the product. The code is a by-product.
You don't write code and document it later. You write the spec, and the code follows.
Principles are beliefs. The framework is the shape they take.
The Harness (MCP) — the agent's hands A controlled execution layer connecting the model to real systems: filesystems, runtimes, databases — over structured JSON-RPC.
The Method (BMAD) — the agent's marching orders A spec-driven framework of machine-readable documents and defined personas that direct what the agent builds.
Harness without method = power with no direction. Method without harness = direction with no power.
Model Context Protocol — the open standard for agent capability.
MCP is the plumbing. It decides what the agent is allowed to touch.
Spec-Driven Development is the discipline. BMAD is how we do it — a multi-document, persona-driven specification method.
The four pillar documents:
The three personas:
BMAD is the blueprint. It decides what the agent should build.
This is the day-to-day mechanics — what you actually do.
The end-to-end loop we follow:
Specify → Harness → Generate → Self-correct → Deploy → Verify.
The specific techniques inside the process:
git diff
Methods are how each step of the process is done well.
The concrete stack you'll operate:
Tools are replaceable. Principles are not.
Learn the Why once, and the How becomes obvious. Learn only the How, and it breaks the moment the tools change.
If you know these words, you can follow everything that follows.
Agent runs the loop. MCP gives it hands. BMAD gives it orders. Surfaces are where it works. Spec is the truth it answers to.
Day 1 starts now: the anatomy of an agent.
FACILITATOR (presenter note, not shown): Cold open — land this before the title sinks in. Don't rush it.
FACILITATOR (presenter note, not shown): keep this to a minute — energy stays on the build, not the rules.