Where we're going, we don't need vibes.
• 13 minute read
• Tags: • Post status: 🪴 SproutI’m not a fan of the term “vibe coding”. It doesn’t do enough to describe the process of working with agentic tools to build software, and I suspect it’s also contributing to the diminishing value placed on user experience and product designers and builders within some corners of our industry. I was much more into the idea of Home-Cooked Software and Barefoot Developers, but alas those terms were far less catchy!
Science, not art
Design has always been done better when paired with methodology and process: Lean UX, design sprints, the double diamond, typography scales, grid systems, Hick’s Law, yadda yadda yadda… are all examples of structured approaches to design. In the same way within teams, good products are built following structures and processes like Agile, Kanban, Scrum. Without these structures, ways of working can quickly become unsustainable, jobs to be done unmanageable, and the product quality and user experience degrades. Things get sloppy, fast.
As technology evolves, perhaps new methodology and process to support us to design and build may also emerge.
Messy… by design?
In the current state of play, I can run any number of conversational threads with agents across different tools at once (eg Claude + Cursor + …), spin up a side chat or five within them, work with multiple AI agents and models in parallel across separate CLI terminal windows and as well as desktop apps and for bonus points, keep chatting to Claude Code via remote control on my mobile phone while I’m on the loo.
I’m feeling a growing unease, where the tools themselves seem to almost encourage a messy, exploratory, stream of consciousness, “vibey” approach, and in the process entice you to drift away from an intentional decision making, structured thinking and methodological workflows, and instead slip into easily-distracted, chase-the-shiny-thing type behaviour. So far I’m successfully holding the line at not coding while pooping, though I observe myself slipping in other ways often! The tooling is feeling increasingly messier, and my assumption is people’s workflows are starting to mirroring this.
Sure we can make rapid, early progress, with the heavily compressed time it now takes to go from 0 - 1 delivering a dangerously strong dopamine rush, but where are the guardrails to help ensure we are designing and building coherent experiences, in coherent, sustainable ways? Seemingly by design, the tooling is playing into the whimsical, chaotic, stream of consciousness nature of humans. Feature? Or bug?
Seeking intentional approaches in the ever-growing sprawl
I’ve challenged myself to seek systematic and methodical approaches to help me design and build intentionally within agentic tooling.
I’m comfortable knowing that in six months time this post will either read like gibberish, or like it was written by a time traveller from the distant past, or that for some reading this it might already seem like either really primitive or advanced thinking. This post is just a snapshot of where my head’s at, today.
My friend Josh Crowley has a concept of “recipes” which I love, but I’ve been thinking about formulas (he says potato, I say tomato). Formulas are the emerging sets of repeatable patterns I’m trying to codify into my process when working with agents. They can be used in isolation, or chained together for deeper and more complex problem spaces and output.
They often begin as tasks I notice I’m consistently repeating manually, a common by-product of the cyclic, loop-based nature of working with agents.
The words I’ve used to name the formulas aren’t new, but wrapping a system around them is, at least for me.
Every formula requires two attributes to be potentially successful, and without them you’re farming out too much of the decision making to a non-deterministic technology, and where’s the fun in that?
Context
Ongoing background and environmental information
Existing rules or guardrails, user preferences, the codebase you're working within, the design system, the purpose of the work, what good looks like, who you are in that moment etc
Inputs
Task specific, short lived information
A prompt, an even ttrigger, a file upload, a data set you're working in, the research to synthesise, a screenshot for inspiration, a URL or API endpoint etc.

Formula 01
Plan
Jesse
Design used to start with a mood board or a pen and paper. Now it can also start in a conversation with an agent. Most tools have a plan mode now, and I lean on it heavily: prompting safely, with no changes being made, lets me tease out the agent's logic and my own at the same time. Planning can scaffold anything from a single small task up to a full backlog, with tasks mapped against priority tiers.
Agent translation
Plan mode runs standard autoregressive generation without executing tool calls, so an incorrect plan costs a re-read, not a rollback. Writing the plan out is what surfaces the ambiguities: left unspecified, the model resolves them silently, defaulting to whatever completion the sampling distribution favours rather than the one you intended. An explicitly tiered backlog is the only priority signal available, since none is encoded in the weights.
Context
Break the job to be done into tasks. Understand what's critical to ship first, and what can wait.
Inputs
Assign priorities, build a backlog, and establish with the agent which tasks need your involvement and which ones can be done autonomously.

Formula 02
Sketch
Jesse
This is a workflow for making something real, prototyping quickly, building a proof of concept you can either throw away or continue to evolve. Sometimes it's easier to attempt the second paint once you've seen the first. Sometimes you need that first paint before you can decide the second one isn't worth doing at all.
Agent translation
Each response is a fresh sample from the model's output distribution over possible next tokens, not a retrieval of a stored answer, so a first paint costs a single inference call, not a rewrite. That changes the economics: it's cheaper to generate several concrete samples and select against them than to fully specify the correct answer in a single prompt upfront.
Context
You need to see whether an idea holds up in reality before committing more time to it. Speed matters more than polish here.
Inputs
A rough brief or direction, permission to move fast and imperfectly, and a clear sense of whether this is a throwaway spike or the start of something that evolves.

Formula 03
Investigate
Jesse
This is where you send the agent to dig into a tricky domain, research a topic in advance, or explore a codebase for clues on how it works. Essentially, it's doing your dirty work. The brief is usually something like: find out everything you can about X, then package it up so it gives me the context I need for what comes next.
Agent translation
A large context window lets the model condition its output on far more source text at once than fits in human working memory, then compress that into a summary. This is not deeper reasoning than yours: it's shallower reasoning applied across a wider input window. Use it to cover ground quickly, then apply your own judgement to whatever it returns.
Context
You need to understand before you act. Good here looks like a clear, well-sourced picture of unfamiliar territory, not a finished decision.
Inputs
The domain or codebase itself, an open question worth answering, and whatever prior art already exists.

Formula 04
Synthesise
Jesse
This is where you use an agent to take advantage of its computational power on large sets of data: synthesising user research, or workshop notes, interrogating customer service call transcripts, drafting design-system guidance from component usage patterns, or working through spreadsheets and datasets that would take you days by hand.
Agent translation
Output here is pattern-matching against statistical regularities learned during training, not domain reasoning. Given an explicit framework in the prompt, it fits patterns to that structure; given none, it defaults to whichever structure is most probable under its training distribution, which may not resemble your domain at all. The framework you supply is what conditions the output on your data instead of its training distribution.
Context
You have more raw material than a person could reasonably process, and you need it turned into something usable: a summary, a pattern, a guideline.
Inputs
The data set, the research to synthesise, the codebase you're working within, and any design system or brand guidelines that should shape the output.

Formula 05
Optimise loops
Jesse
Agentic workflows often run in loops: you provide a prompt, the agent does the work, you check it, then you provide a prompt to refine, the agent does the work again, you check it again, and so on. Some loops start fresh each time, so you have to re-supply the context up front. These feel lossy: nothing persists between iterations. A lossy loop can be turned into one that feels lossless: you stop re-explaining what you've already said, stop burning tokens on it, and stop wearing yourself down in the process. Working with the agent to spot and optimise those lossy loops is what tightens the whole workflow.
Agent translation
Every call is stateless: the model retains no state between turns beyond what is re-included as input tokens, which is the lossy loop by default. Undocumented context has to be re-encoded and reprocessed at full token cost on every cycle. Externalise decisions once, as a file or a skill, and the next call reads them instead of re-deriving them: the loop becomes lossless.
Context
An emerging workflow I've started to enjoy: asking the agent to identify the loops we're working in, and which ones can be turned into skills or improved.
Inputs
The session or workflow itself, where the repetition and cost is showing up, and what's worth codifying so it doesn't have to be re-solved next time.
Chaining 06
How formulas chain
In agentic workflows you can use these individually, or chain them together to create more complex workflows with higher-fidelity, more thoroughly considered output. The value of the formulas compounds as you chain them, as does the methodology and structure around your workflows.
Real life example: You have a well-informed hunch about an opportunity to improve user flow on the platform you work on, and by introducing a new component or pattern into the design system, then shipping it to production, it will give you the leverage to make the update.
Chaining example coming soon… I’ve decided to go hiking for three days and will finish this when I’m back!
- Investigate
Context
Coming soon...
Inputs
Coming soon...
Coming soon...
- Plan
Context
Coming soon...
Inputs
Coming soon...
Coming soon...
- Sketch
Context
Coming soon...
Inputs
Coming soon...
Coming soon...
- Synthesise
Context
Coming soon...
Inputs
Coming soon...
Coming soon...
- Optimise loops
Context
Coming soon...
Inputs
Coming soon...
Coming soon...
Acknowledgement
This post was intentionally written and designed in collaboration with AI agents. I drew the pictures though 💅.