For developers

You already write code. This is for the part that does not come from the compiler: deciding what to build, getting the ask sharp enough that AI builds the right thing, then trusting the output enough to put it in front of people.

This is how I work, not the way. Disagree with it usefully.

Everything in this section

Get to a sharp answer

Get to a sharp answer. Turn a vague request into a brief you can act on.

• Interview me. Let AI ask you the questions and build the draft from your answers.
• Show by example. Give it an example or two and let it infer the shape for yours.
• Give me options. Ask for several distinct candidates and choose.
• Then sharpen. Tighten a draft until two people would decide the same way.

Build it with AI

Build it with AI. Choose how to build, by how big or risky the change is.

• vibeCode. Fast and loose, for small clear work you can eyeball.
• Plan first. Explore and design before you write any code.
• Test first. Write the tests, then let AI iterate until they pass.
• Build carefully. Smaller steps, review each one.
• Finding your way around a codebase. Glob, grep and read are a ladder in increasing order of cost.

Make the output trustworthy

Make the output trustworthy. Check what AI gives you until it is something you can stand behind.

• Ask for a shape, not prose. Hand it a schema and have it fill that in.
• Examples keep extraction honest. Worked examples stop it inventing values that were never there.
• Validate and retry. Feed back the specific failure so it corrects that exact thing.
• Review with fresh eyes. The maker is the worst reviewer of its own work.
• Guard against false positives. One category that cries wolf costs you trust in all of them.
• Keeping the source on every claim. Without the source, a checked figure and a guess read the same.

Set AI up to help

Set AI up to help. Give AI your rules and context so it works the way you do.

• Project memory and rules. The conventions it should already know before it starts.
• Custom slash commands and skills. Package the jobs you do often.
• Path-scoped rules. Guidance that switches on only when it is relevant.
• The tools and information Claude can reach. MCP servers, and why switching one on costs nothing but is not free.

Run it for real

Run it for real. Keep a live system honest once people depend on it.

• Hold the context. Keep the real findings somewhere the conversation cannot round off.
• Know when to step in. Decide in advance what AI handles and what comes to you.
• Fail well. Make failures surface clearly, with enough context to recover.
• When a step goes wrong. Never hide it and never stop everything.
• Where a person should look. Spend limited review time where it changes the outcome.
• When nothing is waiting on the answer. Half the cost if you can wait. One question decides which lane.
• Running Claude in a pipeline. Nobody at the keyboard, so anything that pauses hangs the build.
• The cost is measured, the quality is not. Cost and tests report themselves. The thing that decides whether it was worth doing does not.

Designing the system

Designing the system. The structure underneath the craft: how the work runs, what it can reach and where it is hosted.

• How the AI works. Claude is the intelligence, and how you structure its work is its own set of decisions.
• Where the code runs. Hand the code over and it runs on machines all over the world, with no server to manage.
• Where the content lives. A ready-made place to write, store and publish, with the editing and reading already built.
• Headless and wired with APIs. Splitting the writing end from the reading end, joined by an API.
• When to use AI and when not to. A deterministic step gives the same answer every time. Some work needs that and some needs judgement.
• The two kinds of answer. One has a right answer, the other needs weighing up. They want different machinery.
• Which to reach for. Choosing between them case by case, rather than as one decision about the whole system.
• What each one costs. One is paid for in tokens and time on every run, the other is written once and then costs nothing.
• Which model, once you have decided it is AI. Three tiers, and the same trade wherever you look.

Prompt engineering with Claude

Prompt engineering with Claude. The details worth keeping at hand, the footnotes that shape the design.

• A worked example: what the tools hand back. One example carried the whole way through, showing what each step actually returns.

Build an AI agent

Build an AI agent. Set AI up to run tools and take steps on its own, inside limits you set.

• The agent loop. The loop is your code, not the model's. What each pass does and how it stops.
• Write tool descriptions the model can choose from. The description is not documentation, it is how the model chooses.
• Which tools each agent gets. More tools means worse selection. The cost is in the choosing.
• Work out the steps before you split the work. Whether you hold the pattern already or have to go and find it.
• Let one agent hold the whole picture. The coordinator is the only thing holding the whole job.
• Pass everything the helper needs. If a fact is not passed, it does not exist for that helper.
• Send independent work out together. Parallel is not a setting, it is where the calls sit.
• Hooks that always run. A prompt gives a tendency and a hook gives a guarantee.
• How much to let AI decide. You do not choose a shape, you choose what to decide.
• Guaranteeing the steps that matter. A prompt asks, code guarantees.
• What kind of failure is it. Saying which kind it was is what makes the next move obvious.
• A prompt template is a unit of measurement. What goes into one, and why the name on it is what lets cost, latency, model and quality land on the same row.

Decide what the agent may do

Decide what the agent may do. Where the rules live once there are no screens holding them.

• The forms were the policy. What the screens were quietly enforcing, and why nobody has the list written down.
• Three places a rule can live. In the form, once when it is set up, or at the moment of the call. What each one costs you.
• What permissions were never built for. Composition and context: the two questions roles and privileges cannot answer.
• Inherit the policy, do not rebuild it. Enforce it where it is already enforced, and the agent cannot exceed the person.

Iterating on the decisions

Iterating on the decisions. Holding the decisions apart from the document, what a refining loop can improve and what it cannot.

• The artifact is the only thing that knows what is missing. Precision is not coverage and coverage is what decides how much gets invented.
• Take the countable part off the model. Eleven times the answer was the same and it was never about asking more carefully.
• Checks that report green. The worst result a test can give you is a clean one it was never able to fail.
• Rules that pull against each other. Close every honest exit and a model will take a dishonest one.
• Everything you hand a model becomes material. Including your worked examples, your warnings and the diagnosis you wrote for yourself.

Also in this section

• Working with AI. The map of the craft, and how the six fit together.
• Working with Claude. The same material indexed by what you are doing in the tool.
• The soft skills of working with AI. The human habits underneath all of it.
• recipeCard. The worked example, built in the open.

Start with the framework

The heart of the site is the shape+build+launch framework: 27 short ideas across three stages. Shape is deciding what to make and who for. Build is making it with AI. Launch is putting it in front of people and learning from what happens. Read them in order the first time, then come back by stage when you hit the matching moment in a real project.

Use it in your editor

The framework runs as a skill your AI can follow while you build. In Claude Code, add the marketplace and install it:

/plugin marketplace add vibe2value/claude-plugins
/plugin install shape-build-launch@vibe2value
/reload-plugins

1. After installing, run /reload-plugins to apply it.
2. Then use it, depending on your tool:
   • Claude Code: it surfaces on its own when you are working through a build decision, or call it with /shape-build-launch:guide. Either way it runs the loop with the exact Sharpen prompt for each of the 27 ideas built in.
   • ChatGPT, Claude or Cursor: paste vibe2value.com/skill.txt for the method, or vibe2value.com/skill-full.txt for every prompt inline.
   • Any other tool: point it at vibe2value.com/llms.txt for the full index.

Common questions

1. Where did this come from?
   Much of what is here was put together while I was studying for the Claude Certified Architect Foundations certification. The study was the occasion rather than the point: it made me go back over how I think about this work now, and how that changes the way I actually do it.
2. What is the difference between the two sets of pages?
   Working with AI is the map: six ways of working, laid out in roughly the order a piece of work moves through them. Every page of detail hangs off one of those six.
3. When would I use Working with Claude instead?
   Working with Claude is the same material indexed a second way, by what you are doing in the tool rather than the stage you are at. It is the faster door once you already know the move you want.
4. I already know how to build. Why is this worth my time?
   Writing the code was never the hard part and with AI it matters even less. What is left is a way of working: what you set up before you start, how you cut the job up, and what you check before you believe it.
5. Is a way of working a knack you either have or you do not?
   No. The things on these pages are practices rather than instincts, which means you can pick them up this week rather than wait years to acquire the feel for them.

Want a hand?

If you would rather talk it through, set up a free one-to-one working session and we will find the right starting point for what you are building. No question is too basic or too simple to ask.