Then I decided to share some of the tools I’ve been using to learn about working with AI more deeply and to explore what it means for design as a practice. I made a set of design skills you can use with any model and a set of Inclusive design skills.
This has been pretty handy but next I wanted to explore how a group of design agents would perform and play around with that idea. There’s plenty of room for improvement here, but it has been a very fun experiment and I learned heaps.
I created an open-source design workflow system called Designpowers. It gives you a team of 10 AI agents (each a design specialist) who collaborate to run a complete design process. You direct them as the creative director (human in the loop). They do the work, they hand off to each other, and they show you their thinking as they go.
It covers the full pipeline from discovery through shipping, and it’s free on GitHub.
Why this exists
Most AI tools give you one assistant. You ask it something, it answers, and you figure out what to do next. That’s not how design teams work.
Design teams work because a strategist thinks differently from a visual designer, who thinks differently from a content writer, who thinks differently from someone doing accessibility review. The handoffs between those perspectives are where the work gets better. The friction is productive.
I wanted to build that. Not one AI that tries to do everything, but a team of specialists who pass work between each other, challenge each other’s output, and show you the conversation.
Here’s who’s on the team:
The design-strategist builds your flows, information architecture, personas, and design principles.
The design-scout does competitive research and pattern analysis.
The design-lead handles visual design — layout, colour, typography, components.
The motion-designer takes care of animation, transitions, and micro-interactions.
The content-writer writes interface copy at Grade 6 reading level.
The design-builder converts specs into production code.
The accessibility-reviewer runs WCAG and COGA evaluations on everything the team produces.
The design-critic reviews the work against your brief and principles, finding the gaps nobody else caught.
The inspiration-scout handles aesthetic references, cross-domain inspiration, mood boards.
The heuristic evaluator evaluates a design against established usability heuristics (Nielsen’s 10) and conducts cognitive walkthroughs of key tasks.
Ten specialists all using one shared design state document where all their decisions and conversations accumulate with you directing the whole thing. Here’s an example from my Design Lead:
◆ design-lead: So we've got four open threads — the 320px copy change, the coral AAA question, the breathing pulse concern, and the deferred goal-setting risk. The critic says proceed, and I agree we can ship this. But I want to hear from you: do you want to resolve any of these before we hand off, or are you happy shipping and tracking them as follow-ups? And would you like to run the retrospective to lock in what we learned?
What I learned building it
The act of encoding a design process forces you to decide what the handoffs actually are. When does strategy end and visual design begin? What does the content writer need from the strategist before they can start? What happens when the accessibility reviewer and the design critic disagree? You need a reconciliation step, or the fix round becomes chaos.
The bolded phases are where Designpowers diverges from a standard design pipeline: taste, inspiration, mid-build taste checks, and structured retrospectives.
The agents move through them in sequence, but the interesting part is what happens between them. They write conversational handoff messages you can read. You can watch the design-strategist explain their reasoning to the design-lead. You can see the accessibility-reviewer push back on the builder’s implementation. It’s transparent in a way that most AI tools are not.
I also learned that control matters.
In Direct mode, the pipeline pauses at every handoff for your approval. You steer each transition.
In Auto mode, the agents run the pipeline themselves but with safeguards.
They’ll pause if an agent recommends rethinking the approach, or if the reviewers disagree with each other. You can switch between modes mid-run. Say “go auto” when you trust the direction. Say “pause” when you want your hands back in.
How the system handles taste
Designpowers asks for your aesthetic instincts early: references you admire, how something should feel, what you'd hate. If you have an existing design system, it extracts the taste signals already embedded in your tokens and palette. Then it carries that judgment through every decision the agents make.
The system also remembers: your taste profile persists across projects, strong opinions confirmed over time, soft patterns that are still forming, and anti-patterns you've rejected.
Each new project starts with what the system already knows about you. During the build, it pauses at strategic checkpoints to show you intermediate output and ask specific questions: "is this weight right, or bolder/lighter?", it catches mismatches before they compound.
The idea is simple: agents can verify that a design is correct, aligned to the brief, accessible, consistent. They can't tell you whether it's beautiful. That's your job.
This isn’t about replacing designers
This isn’t a replacement for design judgement. It’s an amplifier for it. A solo designer using Designpowers gets a structured process and a team of specialists they couldn’t afford to hire. A design lead gets a faster starting point for the parts of the work that are structurally predictable, freeing up attention for the parts that aren’t.
How to use it
You can use Claude Code or any other AI coding tool that works in your terminal, VS Code, or browser. Just add Designpowers by cloning the repo and copying the skills and agents folders into your tool’s instruction directory. Everything is on GitHub.
Here’s a few examples of what you can do:
Run a full design process in direct mode: tell it: “I’m designing a medication reminder app for elderly users. Run the full Designpowers pipeline, I want to approve each handoff.”
Quick discovery for a smaller project: tell it: “I need a quick discovery for a settings page redesign. Focus on pain points and competitive patterns, then go straight to design.”
Go auto for rapid iteration tell it: “Go auto. Design a responsive dashboard for a logistics company. Pause if reviewers disagree or if there are critical issues.”
Talk to a specific agent tell it: “I want to work with the design-critic directly. Here’s the mockup, what’s missing?”
Each one gives you a structured design process run by a team of specialists, with every decision documented and every handoff visible.
It’s MIT licensed. Use it, fork it, improve it. If you build something that’s missing, I’d genuinely love a contribution.
What’s next
Designpowers pairs with Jesse Vincent’s Superpowers (which handles engineering: testing, code review, deployment) to cover the full development cycle. Together they’re a proof of concept for something I care a lot about: that a structured, multi-agent design process can work.
I’m curious what happens when more designers start building workflows like this. Not just using AI, but shaping how it works together so that when you ask it to design something, the answer comes from a process, not a guess.
If you try it, I’d love to hear what works, what’s missing, and what you’d build differently. Drop a note in GitHub Issues.
New here? MC Percolates comes out weekly. It’s free. Subscribe and I’ll send you the three posts most worth reading first.
The "creative director" framing is doing a lot of work here and I mean that as a compliment.
Running multiple agents that hand off to each other is where things get interesting - and frustrating. The handoff quality depends entirely on how well you specify the context each agent needs, which is basically the same skill as writing a good brief for a junior designer. People who are good at that already are going to get a lot more out of this.
Did you find certain specialist agents were more reliable than others? In my setups the research/synthesis roles tend to produce much better output than the ones doing generative work.
Dying out of curiosity to dive into the instructions of how you got the agents to challenge each other’s output. From my POV the most interesting part of the setup, including the agent’s reasoning in challenging and being challenged.
The "creative director" framing is doing a lot of work here and I mean that as a compliment.
Running multiple agents that hand off to each other is where things get interesting - and frustrating. The handoff quality depends entirely on how well you specify the context each agent needs, which is basically the same skill as writing a good brief for a junior designer. People who are good at that already are going to get a lot more out of this.
Did you find certain specialist agents were more reliable than others? In my setups the research/synthesis roles tend to produce much better output than the ones doing generative work.
Dying out of curiosity to dive into the instructions of how you got the agents to challenge each other’s output. From my POV the most interesting part of the setup, including the agent’s reasoning in challenging and being challenged.