Hydra.

One body,
many heads.

A design team inside Claude Code. You give it a raw topic, or just a question. Hydra frames it, analyses it, looks at what others do, explores options and builds them into protos with your design system. You get deliverables you can decide on.

What it's for

A screen that underperforms, a new screen to design, a page to audit, best practices for a component, an idea to challenge, a label to choose, a build to check against the design. Hydra does the work of a small team around the designer (analysis, research, exploration, UX writing, design QA), and the designer makes the decisions.

It isn't a screen factory. Hydra thinks before it builds. It works out what is true in your product, looks for what works elsewhere, pits several options against each other, and tells you which one it recommends, why, and on what evidence. It won't just tell you what you want to hear: if an idea is weak, it says so and explains why. And when it doesn't know something, it says so instead of making it up.

How it works

  1. You give it a topic. The problem in one sentence, the current product if there is one, and your documents in the topic's folder, under topics/.
  2. Cortex frames it, in a single message. It says what it found and what's missing, the decision metric and its success threshold, who is affected, the scope, what's already decided, the renders to produce (the screen sizes: mobile, desktop or both, depending on your platform) and how to run the topic. A word from you is enough to correct it.
  3. The heads take over, one after another. Audit works out what is true about the current product. Research finds what others do. Ideation explores options and picks the strongest. Maquette builds every one of them, and Writer checks the copy.
  4. You get the deliverables. Hydra also offers to add what the topic taught it to the context: a metric, a profile, a term. Nothing goes in without your approval.

A request, not always a topic

Not everything needs the whole chain. Hydra picks the heads based on your request; you don't have to name them. It stops at the deliverable you asked for and suggests the next step, without running it on its own.

You askYou get
“Audit this page”, “find the friction points in this journey”The topic sheet and the report: prioritised findings, hypotheses, references, actions. Hydra then offers to explore options.
“What are the best patterns for…”, “best practices for…”A short research deliverable: the answer, how confident it is, the screens as images and links to the sources.
“What do studies say about…”, “what works for…”, on a specific questionA research deliverable: what studies, articles and guides establish, what it means for your topic, and the strength of the evidence.
An in-depth benchmark or state-of-the-art reviewThe topic sheet and a full research deliverable: conclusions, what remains unknown, dated references, including live visits to real products.
“Challenge this idea”, “help me decide”The topic sheet and the report: the options, their critique, a recommendation. Hydra then offers to build them into protos.
“What should this label say?”, “review this copy”Reasoned variants, right in the conversation, or a table for a whole screen.
“Does it match the design?”The design QA: the list of fixes for the developer, with measured values.

Two ways to run it

When framing, Cortex recommends a mode, and you choose.

In one go

  • No pauses: Hydra goes all the way through your request
  • What it had to assume is written down as hypotheses, for you to review
  • Decisions that aren't Hydra's to make come back to you as questions
  • For a well-framed topic with a closed question

Step by step

  • Pauses at the key moments
  • You decide before it moves on
  • Same depth, only the pauses change
  • For a broad topic, where the options still need building

Protos straight away, or after your review. When framing, Cortex also asks when to build the protos, the most expensive part. Either straight away, or after you've read the topic sheet, the report and the brief. In the second case, Hydra stops at the brief, and you ask for the protos if the options are worth it.

Hydra can push back on your request, but it still answers it. If it thinks the problem is badly framed, it tells you, and shows its own reading alongside, clearly labelled. But its options and its recommendation serve your goal, not its own. A constraint from your mission (a legal requirement, a brand principle) changes how the goal is reached, never the goal itself. Some decisions are never Hydra's: defining the problem, the metric and its threshold, the scope. They come back to you, even when it runs in one go.

In your language

Hydra talks to you and writes its deliverables in your mission's working language: the one you write to it in, which the welcome session records. If in doubt, it uses French. In English, everything switches to English: the headings, the deliverable names and the rendered pages. In any other language, the text is in that language and the headings stay in English.

The copy in the protos follows your product's language, which may be different: you can work in English on a product in French. A label or a quote taken from the product stays as it is, never translated. The method itself is written in French, but you never need to read it.

The heads

Each head has its own method. Cortex decides how to run the topic; the others do the work. A topic's discovery phase brings two of them together: Audit, which looks at your current product, and Research, which looks elsewhere. Three heads keep their French names: Maquette (mockups), Recette (design QA) and Accueil (welcome).

Cortex
The conductor. Frames the topic, recommends a mode, calls the heads it needs, and, before closing, checks that nothing was skipped.
Audit
Understanding what you have. Analyses your screen and your journey, live or in a design file, cross-checks them with your documents and your data, and keeps facts apart from hypotheses. To see what others do, it calls Research.
Research
What others do, and what is proven. Screens from real products, searched by what the user is trying to do and not only within your sector. Live visits to products, public design systems, and studies, articles and guides on a specific question, from which it draws what matters for your topic. Every reference is sourced, dated and clickable. The other heads call it when they need references.
Ideation
Open up, then decide. Options that are genuinely different, at least two ways to design each lever, an unsparing critique, and a choice based on stated criteria.
Maquette
Building the screens. One clickable prototype per option, using the components from your libraries, in your platform's renders. Anything your design system lacks is drawn as a sketch, and labelled as such.
Writer
Interface copy. Checks the copy in the protos against your tone of voice guidelines. Without guidelines, it goes by the tone it finds in your product.
Recette
Design against build. Measures both sides, on desktop and mobile, puts a number on every gap, and hands the developer a list of fixes.
Accueil
The first session. Explains Hydra, fills in the context with you from your sources, and starts your first topic.

What you get

A topic's deliverables

  • 01 · The topic sheet: the framing, with the problem, the metric and its threshold, who is affected, the scope, the renders and what's decided
  • 02 · The report: findings, hypotheses, references, options with their critique, and a recommendation. Or the research deliverable (02-research), when research is the topic
  • 03 · The brief: for each option, what the screen must show, and a composition prompt anyone can reuse in their own tool
  • The gallery: one proto per option, on the same starting screen. Only the lever changes, so you can compare them side by side, on mobile and desktop if your platform needs both

The design QA

  • One table per area of the screen, for desktop and for mobile
  • For each gap, the expected value and the value measured on the build, and the severity
  • An annotated screenshot, with the gaps numbered
  • Tables, not prose, because it goes to a developer

Everything is written in the topic's folder, in markdown turned into HTML pages. Visual references are stored there as images you can open anywhere. The protos are HTML pages: they open in the browser, you can click through them, and they never touch your design file. A finished topic goes into topics/.archive/.

The context is your mission

The method is the same for everyone. The context/ folder tailors it to your mission, the client project you're working on: the client, the scope, the business vocabulary, the users, the metrics, the design system, the tone, the tools, the language. Changing missions means replacing this folder, nothing else.

On day one

The welcome session sets up the empty templates and fills them in with you, from your answers, a mission brief or a study readout. The mission file comes first, because it pays off the most: the exact domain, your platforms, the team's real jargon, what the team can take on.

Topic after topic

Nothing has to be complete right away. Each time it frames a topic, Hydra compares what the topic mentions with what the context holds, asks for what's missing, then offers to add it. It writes it with your approval, and never makes things up to fill a gap.

The design system is read from your libraries. Hydra writes up its foundations, the list of components and the usage rules (principles, what's fixed and what's flexible, rules per component, responsive behaviour), and you approve them. If your team already has a design system file in markdown, it's used as is. Users are described along axes rather than as personas: what changes a design decision, and the combinations that come up, each with its strength of evidence. Tone of voice guidelines are optional. Without them, Writer picks up your product's tone and suggests it to you.

Connected to your mission's tools

Hydra isn't tied to any tool by name. It reads the tools your mission declares, role by role, and uses them.

Design tool
Design files and design system. Reads a screen, its structure and its values. For a new screen, takes the components from your libraries.
Benchmark
What others do. Screens and journeys from real products. If you have several tools, it uses them in your order of preference. With none, the welcome session suggests Lazyweb, which is free, and Hydra visits products online.
The browser
Screenshots and measurements. Hydra looks at every proto it builds, and measures the build during a design QA.
Analytics
Usage numbers. When a figure is missing (the value of a metric, the step where people drop off), Hydra looks for it in the tool before calling it missing. It only takes aggregated figures, each with its source. It goes through a connector, or through the tool's API with a key that stays on your machine and never appears in the conversation. With no tool, it reads the exports you drop in.

A tool declared but not connected: Hydra helps you connect it. No tool for a role: it says so, works without it, and lowers its confidence where it matters. Never silently.

The guardrails

What Hydra won't do

  • Make up a component, a value or a convention
  • Claim anything without a source: everything is cited and checkable
  • Suggest a dark pattern: fake urgency, hidden costs, hidden exits
  • Write to your context without your approval
  • Borrow from another topic: a deliverable's structure comes from the method

What its tools check

  • Every proto is captured, and Hydra must look at its screenshots before handing anything over
  • The gallery checks that every option in the report has its proto, and clicks the protos' buttons one by one. A button that does nothing is flagged
  • Deliverables are checked against their template, in English and in French. An undefined mission acronym, or a reference reduced to an ID, is flagged
  • A design QA's totals match its table
  • Any instruction file that isn't Hydra's and gets loaded into the session is flagged

Accessibility and mobile-first design are among the rules every option must meet, along with those your mission declares.

What Hydra doesn't do

What's next

Ideas, not promises:

Who it's for

For a product designer working on a client project who wants a real working partner: someone who analyses what exists, finds the references, challenges their ideas instead of flattering them, and hands over deliverables they can decide on.

Get started

One session, and you're guided through it

You need Claude Code with access to Opus, Node.js 22 or later, and Chrome. You can install Hydra in two ways, and both run the same method: as a Claude Code plugin, for your mission folder only (two commands to install, one to update), or as a copy, downloaded as a ZIP, with no git needed. Requirements and installation are in the README.md, on github.com/MCQX7/hydra-agent.

With the plugin, start Claude Code in your mission folder and write “I just installed Hydra”. It sets up its rules and your context templates there, and the welcome session starts when you restart Claude Code in that folder. With the copy, open a session in Hydra's folder and start with “I just launched Hydra”. The welcome session fills in your context with you; then you start your first topic.

Allow a few minutes for a question, and twenty to thirty minutes for a full topic, through to the protos. Hydra is tuned for Opus at high effort, and that's deliberate. It also works with Sonnet or at a lower effort if your plan doesn't allow more, but its deliverables are weaker.