60% efficiency gain — workflow optimization.
- AI Workflow
- Systems Consulting
- Engineering Productivity
- Embedded Design
A product designer auditing codebases and redesigning how engineers work. It's an unusual brief — and that's exactly why I took it. I'd been deep in AI-native product design long enough to see that the real gap wasn't the tools. It was the workflow around them. This client — a technical product studio shipping across multiple stacks — came to me not for screens, but for systems. So I embedded, audited, and built the practice.
- Role
- AI Workflow Design Consultant
- Timeline
- Mar — Jun 2026
- Team
- Small engineering team
- Tools
- Notion, Figma, Trae, Claude, VS Code
Most of my work lives behind NDAs and embargoes. The walkthrough that matters — the why, the things I cut, the calls I'd make differently — happens in conversation, not on a page.
The client is a small technical studio shipping across multiple stacks and IDE environments simultaneously. They weren't struggling with AI adoption. They were already using it: browser chatbots for code lookup, prompt-and-paste for boilerplate. The question they brought me wasn't "should we use AI?" It was "why isn't it working as well as it should?"
That question is a design problem. The workflows feeding the AI hadn't been designed. Context was unstructured — developers were dropping entire 2,800-line files into paid AI tools when the task touched less than 5% of the code. Every session started cold, with no shared memory of the project. Different task types got the same ad-hoc treatment whether it was a one-line fix or a full cross-stack migration.
They needed a system. That's a different kind of design work — no Figma, no screens — but the methodology is identical: audit the current state, identify the friction points, design the structure that removes them.
How do we turn inconsistent, ad-hoc AI use into a repeatable engineering workflow — without disrupting a team already moving fast?
60% efficiency gain. System, not tools.
30% from SOP task modularization — routing each task type to the right workflow. 30% from context architecture — single source of truth plus extraction protocol. Pilot task token reduction: 88%.
Single source of truth — one file the AI always reads first.
The first system I designed was a `project_context.md` standard: a structured file in every project root containing tech stack version, naming conventions, utility function index, API call patterns, and special design rules. Before this, every AI session started from scratch — the model had no memory of the project it was working in, so developers spent tokens re-explaining context that should have been there by default.
The second layer was a context extraction protocol for large-file tasks. Developers were feeding entire files (2,800+ lines) into paid AI tools when the relevant code was under 5% of the file. I designed a two-step workflow: use a free AI to extract only the relevant imports, methods, and reference implementations — then hand that extraction to the paid tool for generation. Pilot result: input dropped from 75,000 → 8,500 tokens (88% reduction), with total session cost falling an estimated 55–70%.
“Every session was starting from scratch. The model had no memory of the project it was working in.”
Five types of AI work. Different workflow for each.
The deeper problem was that developers were treating all AI-assisted work the same. A small edit in a 2,800-line file and a full cross-stack migration aren't just different in scale — they need different context strategies, different tool configurations, and different review protocols. I ran structured interviews and workflow analysis across the team to surface this, then built the taxonomy that made it actionable.
Five types: Type A (small edits in large files), Type B (new feature development using existing patterns), Type C (cross-stack migration), Type D (external docs → code), Type E (refactoring/architecture). Each type has a defined context preparation method, tool recommendation, and review step. Type A was the only SOP fully validated at project end — by design, because shipping five unvalidated SOPs would have created a different kind of overhead. The taxonomy itself drove ~30% of the efficiency gain by routing each task to its right workflow.
“The taxonomy drove 30% of the efficiency gain — not because the tools changed, but because the task routing did.”
Where I made the calls.
- 01Audited the engineering team's codebase and full tool stack — 6 AI tools tested across 4 IDE environments — to map where workflow friction was highest.
- 02Designed and deployed the `project_context.md` standard: a single source of truth per project that gives AI consistent context on every task — tech stack, naming conventions, utility index, API patterns — eliminating the per-session re-explanation overhead.
- 03Built and validated the context extraction protocol: a two-step workflow (free AI for extraction → paid AI for generation) that reduced pilot task input from 75,000 to 8,500 tokens (88%) and estimated total session cost by 55–70%.
- 04Developed a 5-type task taxonomy (Type A–E) and SOP framework, giving developers a structured path for routing any AI-assisted task to the right context strategy, tool configuration, and review protocol. Type A fully validated on pilot; B–E scoped for subsequent phases.
- 05Produced all Phase 2 deliverables: AI tool evaluation report (6 tools, scored and ranked), pilot task effect record with before/after token data, best practices documentation distributed to team.
The bottleneck was never which tool.
Every AI adoption conversation starts with tool selection. This engagement started there too — 6 tools, 4 IDEs, a full evaluation matrix. But the tool choice turned out to matter less than the workflow around it. The engineer who made the most meaningful before/after progress wasn't using the "best" tool — they were using a built-in tool with proper context provided. Context quality beat tool quality every time.
The part I'd port forward into any future AI adoption engagement: the single source of truth. `project_context.md` is a 10-minute setup with compounding returns — every AI session after that starts warm instead of cold. It's the cheapest, highest-leverage design artifact in the system.
