Product Design Workflow Plugin
Turning my design practice into a tool that runs the full process, research to handoff, and asks for approval at every step.
TYPE
ROLE
BUILT WITH
1
Set up
2
Discover
3
Define
4
Design & test
5
Deliver
Context
My design process has evolved over the years, across different companies and teams. Research methods got sharper, problem framing got clearer, and how I moved from concepts through to handoff kept changing as I learned what actually worked. What never changed is that none of it lived anywhere permanent. Every new project meant starting over from scratch.
I wanted that process of years of refinement to live somewhere other than my head and a stack of templates. So I built it as a Cowork plugin: a set of skills that run my actual design practice, in order, with my own standards for evidence, writing and approval built in.
Problem
Three things kept slowing me down, and I guessed other designers felt them too.
My process lived in my head. Every new project meant rebuilding structure, checkpoints and templates from memory.
Rigor dropped under time pressure. Research, evidence and accessibility were the first things to get rushed or skipped.
Nothing carried over between projects. Lessons learned on one project rarely made it into the next one in any structured way.
My role
Mapped my own end to end process into 23 steps across six phases.
Designed the system architecture: one skill per step, chainable, each with its own approval checkpoint.
Wrote the decision rules for every step: when to use synthetic research, when a design system is missing, how project size changes what runs.
Built, tested and iterated the plugin using a real concept project.
Defined the principles the whole plugin runs on: evidence over assumptions, no invented numbers, private by default.
Approach
Mapping the process first
I started with the five phases I already used on every real project: set up, discover, define, design and test, deliver. Before writing a single skill, I wrote down what each one actually involved, from a first brief to the post launch review.
The 23 steps came later, from use, not from planning. As I ran real work through the plugin, each phase split into the sub skills it genuinely needed: research synthesis pulled apart from benchmarking, prototyping pulled apart from accessibility review and content design. Six phases held. The steps inside them grew to 23.
Principles
1
Evidence over assumptions. Every claim links to a source or is labelled assumption. No invented numbers.
2
Approval at every step. A short summary, three choices: approve, change, redo. Nothing moves on its own.
3
Private by default. No accounts created, no logins. Designs stay confidential until I say otherwise.
4
Works without connectors. Figma, Miro, Mobbin and analytics tools make it richer, but nothing is required to run it.
5
One writing style, every output. Short sentences, plain words, no dashes, consistent across every document the plugin produces.
6
The plugin keeps learning. Gaps found in real projects become updates, always with my approval.
Where it stands now
23 skills built and chained into one continuous workflow, from brief to post launch review.
Running end to end on a real test project
Built so any product team can install it and get the same rigor, not just me.
Learnings
1
Writing it down was the hard part. Mapping every step forced me to notice the moves I had been making by instinct, the ones that never made it into any template, and name them properly for the first time.
2
Trust comes from stopping, not speed. The checkpoint at every step is what makes the plugin usable on real work, not the shortcut.
3
A process built for one company breaks fast. Designing it to work for any team meant removing every personal shortcut and hidden assumption.
Next steps
1
Finish testing end to end on other projects
2
Keep iterating and improving
3
Get feedback from designers