AI as a Service Design Layer
Welcome · 01 / 17
ISB1 · Digital Service Innovations · ITP Summer 2026

Day 7

Designing & Building AI Services · Wednesday 17 June

Mohammad Soltaniehha· Boston University
AI as a Service Design Layer
Day 7 · 02 / 17
DSI 2026 · Generative AI for Service Design

Design it. Then build it.

Six design principles, prompts as prototypes, delegation by design. Then the advanced Claude Code toolkit, and a build sprint for your first working prototype.

Today’s podcast · generated by NotebookLM
Who Is Really Prompting Who?
--:--
01 · READINGSA method, in three papersWeisz’s principles · prototyping with prompts · algorithms that delegate
02 · THE FIVE PRIMITIVESSkills, MCP, subagents, hooks, pluginsPlus Plan Mode and the human-handoff pattern
03 · BUILD SPRINTYour AI service prototypeFrame, prototype, build, delegate · a first working version
AI as a Service Design Layer
Readings · 03 / 17
Reading 1 of 3 · designing & building AI services

Six principles for generative AI.

Developed at IBM over four iterations and tested by 18 practitioners on 9 commercial GenAI products.

Weisz, He, Muller, Hoefer, Miles & Geyer (2024) · Design Principles for Generative AI Applications · Proceedings of CHI 2024
Known AI issues, reinterpreted
01Design ResponsiblySolve real user problems; test and monitor for harms
02Design for Mental ModelsTeach users how to work with the AI, and teach the AI about the user
03Design for Appropriate Trust & RelianceCalibrate skepticism; use friction to avoid overreliance
New with generative AI
04Design for Generative VariabilityMany distinct outputs is a feature. Compare them, pick, remix
05Design for Co-CreationLet users steer generation: controls, parameters, co-editing
06Design for ImperfectionMake uncertainty visible; offer ways to evaluate and improve outputs
AI as a Service Design Layer
Readings · 04 / 17
Reading 2 of 3 · the prompt is the prototype

Prototype with prompts. Start from content.

13 industry teams of PMs, engineers and designers designed an LLM feature. What worked, and what burned them.

Subramonyam, Thakkar, Ku, Dieber & Sinha (2025) · Prototyping with Prompts · Proceedings of CHI 2025
Anatomy of a prompt≈ your CLAUDE.md
Contextbackground and task details the user provides
Instructionwhat the model should do: task, action, outputs
Constraintsformat, length, guardrails
Examplessamples that anchor quality
Three ways teams got burned
×Prompt sensitivityConstraints get ignored: asked for under 100 characters, got 174
×Baked-in stereotypesPrompts encoded audience assumptions; outputs reinforced them in 4 of 13 sessions
×Overfitting to one exampleEvery output cloned the single gold sample. Test prompt parts by removing them (ablation)
The method: write the ideal output first, then reverse-engineer the prompt that produces it.
AI as a Service Design Layer
Readings · 05 / 17
Reading 3 of 3 · designing for failure

Decide where a human stays in the loop.

Inside Uber: algorithms delegate to humans through a continuous loop. And the loop runs on human input.

Stelmaszak, Möhlmann & Sørensen (2025) · When Algorithms Delegate to Humans · MIS Quarterly 49(1)
01AppraiseWhich human can do this? Algorithms assess users from their data.multi-data assembly · learning-based assessment
→
02DistributeHand out rights and responsibilities: who drives, who decides.programmed division · dynamic diffusion
→
03CoordinateMonitor and align actions toward the shared goal. Then the loop repeats.static monitoring · adaptive alignment
The loop runs on human input: trace data, choice data, and humans taking over at breakdowns. Appraising drivers for a single match draws on at least 6 cooperating algorithms. 63 UBER PATENTS · 22 INTERVIEWS
AI as a Service Design Layer
Readings · 06 / 17
Today’s brief · service design workshop

Build sprint: your AI service.

A Claude Code framework.

01FrameExploration or optimization? Pick the 2 design principles you will demonstrate.Weisz et al.
02PrototypeWrite the gold output for your Day 4 population, reverse-engineer the prompt, run one ablation.Subramonyam et al.
03BuildBLUEPRINT.md & CLAUDE.md as service script, skills as capabilities, MCP connectors as backstage.Claude Code
04DelegateDefine when and how your AI hands off to a human, before it breaks.Stelmaszak et al.
Deliverable: a first working version of your AI service prototype. Tomorrow we stress-test it.
AI as a Service Design Layer
Design patterns · 07 / 17
A service-design lens

Three ways to put AI in a service.

// pattern 01
Embedded AI
// invisible
User sees
A normal form. A normal list. A normal button.
AI does
Quietly tags, ranks, routes and scores in the background.
Trust lives in
The brand. Users may not even know AI is involved.
Booking form→ AI silently classifies "member" vs "guest"
→ routes to the right queue
// pattern 02
Copilot
// side-by-side
User sees
A draft. A suggestion. A "send" button they control.
AI does
Proposes. Never commits. The human stays in the loop.
Trust lives in
The review step. Humans approve every action.
Host's inboxAI drafts the reply →
host reads, edits, clicks send
// pattern 03
Autonomous agent
// operates
User sees
A confirmation. An exception. A handoff when things get weird.
AI does
Acts on its own: confirms, emails, waitlists. Runs until a guardrail fires.
Trust lives in
Explicit failure modes. The handoff is the design.
Booking agenthandles routine →
escalates on first-time guests or peak days
AI as a Service Design Layer
The primitives · 08 / 17
Anatomy of an AI app

Five primitives. Mix and match.

P PLUGIN a bundle that wraps the four below
// you talk to Main agent
S
Skill
A folder of instructions, scripts & references. Loaded on demand.
M
MCP server
A standard protocol for giving the agent new tools and data.
A
Subagent
A worker the main agent delegates to. Runs in its own context.
H
Hook
Code that fires on lifecycle events (before/after a tool call, etc).
AI as a Service Design Layer
The primitives · 09 / 17
Primitive #1 · Skill

A folder of instructions loaded only when needed.

// skills/service-blueprint/SKILL.md
---
name: service-blueprint
description: Draft a 3-lane service blueprint with customer actions, frontstage, and backstage.
---
# How to draft a service blueprint
When the user asks for a blueprint, start by listing the customer’s
journey moments. Map each one to the frontstage actor and the…
+ 2,400 more lines & 4 reference files
1
Always loaded
Just the name & description. Agent learns the skill exists.
~80tokens
2
Loaded on match
When user’s task fits the description, the full SKILL.md gets pulled in.
~3ktokens
3
Loaded on demand
Reference files & scripts only when the SKILL.md tells the agent to fetch them.
0tokens until fetched
AI as a Service Design Layer
The primitives · 10 / 17
Primitive #2 · MCP server

Model Context Protocol (MCP)

MCP servers are programs that expose specific capabilities to AI applications through standardized protocol interfaces.
Think of MCP as a USB-C port for AI: one standard plug for every tool and data source.
// you talk to
Main agent
MCP socket
MCP
// drive
Google Drive
list_filesreadsearch
// vcs
GitHub
open_prlist_issues
// db
Postgres
queryschema
// design
Figma
get_framelist_components
// Before MCP:every agent re-implemented every integration.
// After:build the server once, every agent in the world can use it.
AI as a Service Design Layer
The primitives · 11 / 17
Primitive #3 · Subagent

Send the messy work somewhere else.

Main agent your conversation
find every place we call the payments API and list them
→ delegating to a subagent so my context stays clean
← found 14 call sites across 6 files. Most are in /server/checkout. Want me to refactor them?
yes, start with checkout.ts
→ brief ← summary
Subagent fresh context · isolated
brief: find every call to the payments API
grep "paymentsClient" → 38 matches
read server/checkout/index.ts
read server/checkout/refund.ts
read server/billing/invoice.ts
read web/cart/page.tsx
read web/account/billing.tsx
grep "createCharge" → 6 matches
read tests/integration/checkout.test.ts
read server/webhooks/stripe.ts
summary: 14 unique call sites, 6 files, mostly /server/checkout
AI as a Service Design Layer
The primitives · 12 / 17
Primitive #4 · Hook

Code that fires on lifecycle events.

start SessionStart
turn UserPromptSubmit
before PreToolUse
fires ↓ PostToolUse
turn end Stop
end SessionEnd
// auto-format hook
on: PostToolUse(Edit)
run: prettier --write $FILE
// guardrails
Block edits to .env in PreToolUse
// quality
Run the linter after every Write
// audit
Log every tool call to a CSV
AI as a Service Design Layer
The primitives · 13 / 17
Primitive #5 · Plugin

A bundle. The unit of sharing.

design-team-kit/
├─skills/
│  ├─service-blueprint/SKILL.mdS
│  └─press-release/SKILL.mdS
├─agents/
│  └─researcher.mdA
├─hooks/
│  └─post-edit-format.shH
├─.mcp.jsonM
└─plugin.jsonv1.0.0
$ claude plugin install design-team-kit
One folder holds two skills, an MCP server, a subagent, and a hook. A teammate installs it with one command.
4,200+
shareable skills
770+
MCP servers
2,500+
marketplaces
// ecosystem · May 2026
AI as a Service Design Layer
Exercise · 14 / 17
Your turn · install a plugin

Give Claude superpowers.

A plugin bundles a whole way of working. This one ships 14 skills and a session hook that makes Claude reach for them on its own — spec first, test first, no setup.

superpowers · by Jesse Vincent (obra) · read more at claude.com/plugins/superpowers
What’s inside
14 skills 1 session hook
brainstormingpulls a spec out of you before any code
writing-plansturns that spec into a step-by-step plan
test-driven-developmentwrites the test first, then the code
subagent-driven-developmentagents run the plan and review each other
Install it
Terminal · Claude Code CLI
/plugin install superpowers@claude-plugins-official
/reload-plugins
Desktop app
  • Same two commands work, or:
  • Type /plugin, open the Discover tab
  • Search superpowers, click Install
  • Run /reload-plugins — no restart
Then just build. You do not call the skills — they trigger themselves. Try it on your sprint: say “brainstorm this with me” and watch it ask before it writes a line.
AI as a Service Design Layer
Working with Claude Code · 15 / 17
Design before execution

Plan first. Execute later.

Shift+Tab×2 // toggle Plan Mode
Plan Mode tells Claude to draft the steps first: read the files, write a numbered plan, ask what's missing, stop. Nothing changes on disk until you approve.
// why it matters
  • Catches ambiguity before the agent damages your repo
  • Claude asks its clarifying questions up front, in the plan
  • Lets you fork the plan, not the codebase, when you don’t like the approach
  • Cheaper: most thinking happens before any tool calls fire
// without plan mode 200 lines
wrong direction
// with plan mode 4 steps,
spot the bug in 20 sec
PLAN MODE
> refactor the booking flow to use the new payments SDK
I’ll work through this in 4 steps:
1. Read /server/checkout/* to map current call sites
2. Check the new SDK’s auth flow (different token format)
3. Refactor 14 call sites behind a feature flag
4. Update integration tests for the new SDK shape
? Question: should the feature flag default to old or new SDK in dev?
→ Approve plan · ✎ Edit · ✗ Cancel
AI as a Service Design Layer
Designing for failure · 16 / 17
Graceful degradation

Design the handoff, not just the happy path.

1AI acts
Acts on its own, inside the rules you wrote in CLAUDE.md.
→
2Trigger fires
Any one of:
low confidence sensitive / high-stakes case cost ceiling hit
→
3Hand to a human
The human takes over with full context. No dead end, no silent failure.
The hook
Fable 5 flags its own uncertainty. Wire your trigger straight to that signal: the model tells you when it’s unsure, so you don’t have to guess.
escalation rules live in CLAUDE.md the autonomous-agent pattern, made safe
AI as a Service Design Layer
Bonus skill · 17 / 17
One more skill · before you commit to a design

Have Claude grill your plan.

A skill is just a file: a name, a description of when to use it, and the instructions. This one makes Claude interview you about your plan, one question at a time, until it holds up.

grill-me · from Matt Pocock’s open skills collection · github.com/mattpocock/skills
.claude/skills/grill-me/SKILL.md
---
name: grill-me
description: Interview the user relentlessly about a plan or design until reaching shared understanding, resolving each branch of the decision tree. Use when user wants to stress-test a plan, get grilled on their design, or mentions "grill me".
---
Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time.
If a question can be answered by exploring the codebase, explore the codebase instead.
Install it · paste into Claude Code
> Install this skill locally for me, from this link: https://github.com/mattpocock/skills/blob/main/skills/productivity/grill-me/SKILL.md
No link handy? Paste the SKILL.md text above into the same prompt instead. Once it is installed, just tell Claude “grill me” and it starts asking.