Fast-Moving AI, Slow Human-Centered Design
AI features were going from idea to release in weeks. The design process around them hadn't changed in years.
Microsoft's Business Innovation Center (BIC) builds AI capabilities into business applications and Copilot Studio. Its designers were working at a pace their process was never built for: research, validation and user feedback were the first things to go when a deadline moved, and nobody had a shared way to say what “responsible” meant for a feature that was due next sprint.
That gap carried two risks. Features could ship that didn't meet real user needs, and AI behaviour could slip past ethical lines that nobody had time to check. BIC partnered with SCADpro, SCAD's industry collaboration studio, to find a better way, and I was asked to run the project.
0
people on the team, from strategy and research to visual design and code
0
Microsoft stakeholders across design, research and content
0
designers, PMs, researchers and leads interviewed
0
deliverables in the original brief, with no fixed shape
Problem Statement
AI was evolving faster than design processes, leaving Microsoft's designers without the tools, frameworks or shared alignment to keep AI experiences human-centered across teams. Whatever we built had to fit inside crunched timelines, not ask teams to slow down.
From an Open Brief to a Clear Scope
The brief asked for a process, a framework, principles, a toolkit, case studies and a presentation. One quarter can't hold six projects, so the first job was turning it into one.
Microsoft's goal was ambitious and deliberately open: a responsible, human-centered framework that embeds AI into product development from the start. I ran kickoff and alignment sessions with the BIC stakeholders to find out which of the six deliverables mattered most, and what would prove the work was useful rather than just interesting.
“A responsible, human-centered framework that embeds AI into product development from the start.”
- 01Documented AI-HCD innovation process
- 02Visual workflow diagrams
- 03Design principle framework
- 04Toolkit for design teams
- 05Case studies applying the process
- 06Final presentation
The answer reshaped the project. A new process diagram would be forgotten within a quarter; principles that teams actually used, with evidence that they used them, would not. So the scope became three linked things: principles worth following, a light system that keeps teams honest to them, and a report that proves it to leadership.
Principles Before Product
- Decision
- Make the principles the core deliverable, and design every tool to apply or measure them, instead of producing a standalone process document.
- Trade-off
- Less visible output early on, and a harder conversation with stakeholders who expected a process map.
- Why
- A process is followed when there's time. Principles that are checked every day are followed when there isn't.
Finding Where Principles Break
Everyone agreed principles mattered. We needed to know why they disappeared somewhere between kickoff and launch.
I split the research into two tracks run in parallel. Three secondary research pods covered team culture and mindset, current collaboration, AI capability design and principles in practice, each with a lead and a weekly rhythm of findings. Alongside them, a primary research track ran in-depth interviews with the people who live the problem.
How do team culture and beliefs shape the way AI gets designed?
How do design, engineering and product work together on AI today?
How are AI features scoped, explained and validated?
Which principles exist, and where do they stop being used?
We spoke to 34 people across Microsoft and other product teams: designers, PMs, researchers and team leads. Every interview fed one shared affinity board, so the pods were never synthesising in isolation. Three patterns came back again and again.
- 24Designers
- 4Product Managers
- 4Researchers
- 2Team Leads
Principles Don't Reach Practice
Designers knew the principles existed, but nothing in their day turned them into decisions. “We're just told: here's a feature.”
Alignment Starts Too Late
Teams rarely agreed what mattered before building, and had no way to track ethical choices once they did. “How do we make sure our intentions actually stay in the product by the time it ships?”
Reflection Comes After Launch
Retrospectives looked at velocity, not values, if they happened at all. “Sometimes we only realize what we missed after it ships.”
Eight Principles and a System to Keep Them
The research didn't call for more rules. It called for a few clear principles and something that brings them back at the right moment.
We wrote eight AI-first design principles, built from the research, Microsoft's Responsible AI guidelines and HCI ethics. Each one is short enough to remember, phrased as something a designer can do, and broken into sub-principles that can be checked against real work.
Keep Humans in the Loop
Keep people in control of critical AI actions. Provide checkpoints to review, confirm or override decisions.
What the scorecard checks- Rejection & override options
- Escalation for ambiguity
- Visible accountability trail
Principles only change behaviour if they show up during the work. An ideation workshop across all four disciplines produced concepts from synthetic users to research pop-ups, and two were taken to prototype: a physical, rubber-duck style desk companion, and Mictreesoft, a digital tool. We tested them side by side.
Ideation Workshop



A/B Concept Test
Mictreesoft won on four of five measures. The desk companion felt more functional, but people trusted it far less.
With Mictreesoft chosen, I mapped the whole system across a project's life: align on the principles that matter at the start, apply them through light touch-ins in the middle, and reflect on them with evidence at the end. Each phase asks as little of the team as possible.
The Framework
Nudge, Don't Audit
- Decision
- Build a light daily touchpoint, one question a day inside the tools teams already use, rather than review gates or long checklists.
- Trade-off
- Less control over whether teams engage, and a design that depends on staying genuinely useful.
- Why
- Teams under deadline skip anything heavy. A thirty-second question gets answered; a checkpoint gets postponed.
Running 21 People Like a Product Team
A team this size can go wide very fast. My job was to make sure it went somewhere together.
The team brought four disciplines: design technologists, researchers, design strategists and visual designers. I organised them into cross-functional pods with clear owners, ran the project in short agile sprints, and kept a single roadmap that both SCAD and Microsoft could read at a glance.

Rituals kept 21 people moving as one. Daily stand-ups surfaced blockers early, sprint planning and reviews tied each pod's work back to the scope, and regular check-ins with the BIC stakeholders meant there were no surprises at the midpoint or the finish. Retrospectives closed every sprint.
We also agreed how we'd work together. A short team charter set the tone: open minds, actionable feedback focused on the work, accountability for what you own, and respect for each other's time, including no messages after 6 PM. It sounds small, but it kept a large team generous with each other under deadline pressure.
Pods With Owners, One Shared Board
- Decision
- Split the team into small cross-functional pods with named leads, but synthesise everything on one shared board and one roadmap.
- Trade-off
- More coordination for me, and pods had to give up some independence in how they reported.
- Why
- Small pods move fast; a shared board stops them from building three different answers to the same question.
From Prototype to Practice
Mictreesoft had to work, not just look like it worked. So I built the intelligence behind it while the team designed the experience around it.
As the team's design technologist, I built Mictreesoft's engine as a crew of three AI agents running on Microsoft's internal models. The first reads a project's context and writes a question of the day, weighted toward the principles the team chose. The second scores how well the team's answers adhere to each principle. The third turns everything into an executive report that ties design behaviour to business outcomes.
The experience is built around a tree. Every project starts as a seed; each honest answer helps it grow, and each principle hangs from its branches with a live adherence score. It turns something abstract into something a team can see, care for and be a little proud of. Try it below.
- Seed
- Sprout
- Sapling
- Young Tree
- In Bloom
I presented the final system to Microsoft's BIC stakeholders on May 27, 2025, alongside the team. We showed the principles, a live walkthrough of Mictreesoft on a sample Copilot project, and the executive report it produced.
The Curtain Call



Make Adherence Visible to Leadership
- Decision
- End every project with an executive report that scores principle adherence and links it to design, product and business metrics.
- Trade-off
- Scores simplify nuanced judgement, so the report pairs every number with the team's own reflections.
- Why
- Principles become a priority the moment leaders can see them. The report turned ethics from opinion into evidence.
Mictreesoft, Redesigned
The delivered flows and system, redrawn with a 2026 finish: how I'd present Mictreesoft today. The sample project and its numbers are illustrative.
Principles That Grow With You
Microsoft didn't just like the work. They kept it.
0
AI-first design principles adopted by Microsoft BIC
0
AI agents powering alignment, scoring and reporting
0
people whose experience shaped the principles
0
interaction pattern merged into Copilot and deployed
The stakeholders singled out the principles as the novelty they hadn't seen elsewhere, and the executive report as the piece that made ambiguous design work clear, adding proof and accountability where there had only been intent. BIC adopted both the principles and the reporting style. The interaction design behind the tree, a light daily nudge that keeps principles in view while you work, was merged into Copilot and deployed, without the tree.
What I Learned
Scope Is the First Design Decision
An open brief is an invitation to do everything. Choosing one core idea early made every later decision easier for 21 people.
Make Values Measurable
Principles stay posters until something checks them. A small, regular signal did more than any framework document.
Build to Earn Trust
Coding the agents myself meant stakeholders saw a working system, not a promise, and that changed the conversation.