AI changes every week. Your operating system should not. This manual is a way to make a good decision before opening a chat box: choose the job, choose the working mode, give the system a usable contract, and decide how you will know the work is right.
This is deliberately not a leaderboard. Model rankings expire quickly, and the “best” product depends on the task, the data, the deployment, and the cost of being wrong. The durable advantage is knowing how to structure work so that today’s best available model can help without becoming an unaccountable black box.
- 01 Frame the job Name what must exist at the end.
- 02 Pick a mode Ask, research, create, delegate, or automate.
- 03 Write the contract Set context, constraints, proof, and permissions.
- 04 Choose the tool Route the job to the right product and model.
- 05 Verify the result Match the checks to the consequence of error.
- 06 Capture the miss Turn failures into the next contract and eval.
1. Begin with the job, not the logo
Before choosing a model or product, answer four questions:
- What must exist at the end? An answer, a sourced brief, a deck, a code change, or a recurring result?
- What evidence must support it? Primary sources, calculations, passing tests, an approved brand system, or human judgment?
- What is the consequence of a mistake? Private rework, a confused colleague, a customer-facing error, a security incident, or money moved?
- Will this exact shape of work recur? Once, occasionally, or on a stable schedule?
These answers select the working mode. The model comes after.
2. Use five working modes
| Mode | Use it when | Example | Proof of done |
|---|---|---|---|
| Ask | You need one bounded answer or transformation. | Rewrite a note, explain a concept, outline options. | You can inspect the answer directly. |
| Research | The answer depends on current or unfamiliar evidence. | Compare a market, verify a claim, scan a policy change. | Claims trace to current primary sources. |
| Create | You need an artifact, not just prose in a conversation. | Build a deck, spreadsheet, image, memo, or code patch. | The artifact opens, renders, and meets its brief. |
| Delegate | The job has several bounded steps, tools, or files. | Investigate a bug, implement a feature, assemble a diligence pack. | Checkpoints, tests, and a final review make the work inspectable. |
| Automate | A stable, proven workflow should run on a trigger or schedule. | Compile the weekly AI signal, triage a queue, generate a standard report. | Runs are observable; failures stop safely and reach an owner. |
A 30-second decision path
- Can one response finish the work? Use Ask.
- Does the answer depend on fresh facts or a body of sources? Use Research.
- Does someone need to open, present, run, or edit the output? Use Create.
- Are there multiple bounded steps or tools? Use Delegate.
- Has the same workflow succeeded repeatedly with clear exceptions? Consider Automate.
Do not automate the first draft of a workflow. Run it manually, learn where judgment is hiding, and only then turn the stable parts into a template, skill, agent, or scheduled task.
3. Give the system a work contract
Vague prompts create plausible motion. A work contract gives the model enough context to act and gives the human a basis for review. Use six fields:
GOAL
What should exist when this is done?
CONTEXT
Who is this for? What happened before? What files or systems matter?
CONSTRAINTS
What must it preserve, avoid, or never do?
DONE
What observable conditions prove completion?
EVIDENCE
Which sources, tests, calculations, or examples must support the result?
PERMISSIONS
What may it read, change, send, publish, spend, or deploy?
For a small request, this can be six lines. For a codebase, the contract belongs in repository instructions such as AGENTS.md or CLAUDE.md, plus the issue, tests, and local documentation. For a recurring workflow, make the contract a maintained template instead of re-inventing it in each chat.
4. Choose the job, then the tool
Do not begin with “Which AI is best?” Begin with “What must someone be able to do with the result?” The routes below are DVx starting points as of July 30, 2026—not permanent endorsements. Use an approved enterprise workspace whenever company, customer, or portfolio data is involved.
For routine thinking, writing, and analysis, start in the approved ChatGPT, Claude, or Gemini workspace. The surrounding product matters more when the output must become a deck, working prototype, code change, sourced report, reusable campaign asset, or governed system.
I need to make a presentation
Start here when you have a prompt, outline, or document and need a coherent narrative draft quickly. Gamma structures the deck, applies a theme or brand, and exports to PowerPoint, PDF, or Google Slides.
Start here when the deck should follow a design system, feel more bespoke, or use interactive HTML and animation. It supports conversational iteration and exports to PPTX, PDF, HTML, and other tools.
Start here when the deck is one asset in a larger campaign. Brand Kit, shared templates, stock media, collaboration, and easy resizing make the output simpler to reuse across channels.
Switch when the deck needs original information design, audited data visualization, or pixel-level art direction. Use the AI draft as a brief for a designer, not as the final artifact.
I need a product prototype people can use
Turn a PRD, ticket, document, or wireframe into a shareable web prototype with real flows, state, data, and authentication. Validate the interaction, then sync the code to GitHub for engineering review.
Use when visual direction and your existing components matter more than backend fidelity. A design can be handed to Claude Code when it is ready to become software.
Switch when the work is native mobile, must fit a mature repository, or carries production security and reliability requirements. A convincing prototype still needs engineering validation, tests, and an operating owner.
I need a large change in a real codebase
Use when the task must read the codebase, coordinate edits across files, run commands, and verify behavior. It is a strong fit for coherent feature work, debugging, tests, migrations, and long-running repository tasks.
Use for codebase understanding, multi-file refactors and migrations, test coverage, and tasks that benefit from a reviewable queue or parallel attempts. Give it repository instructions and an observable definition of done.
Switch when the edit is small enough for direct coding or inline completion. For recurring work, run a bakeoff: the better agent is the one that follows your repository contract and returns verified, inspectable changes with less review burden.
I need a sourced answer or decision brief
Use an approved assistant’s deep-research mode when the question requires a multi-step search across current public and connected sources. Require a source list and inspect the claims that drive the recommendation.
Use when the answer should stay grounded in a known corpus: diligence files, customer research, policies, papers, or project documents. Select the sources deliberately and follow citations back to the originals.
Switch when the conclusion is consequential, the evidence is paywalled or domain-specific, or citations do not support the claim. AI research accelerates source review; it does not replace it.
I need branded campaign assets
Use when the team needs editable social graphics, one-pagers, presentation assets, images, or campaign variants inside one brand system. Start from Brand Kit and reusable templates, then generate or edit media in that context.
Switch when identity, product accuracy, usage rights, or a new visual system is the work. Bring in a designer and treat generated imagery as material to direct and review.
I need company-controlled model access
Use Google Cloud’s Agent Platform, formerly Vertex AI, when IAM, project billing, regions, model access, and version pinning belong in GCP. Claude Code can use it as the model provider while remaining the coding harness.
Switch when an approved managed product already provides enough control. Do not take on platform setup unless centralized access, auditability, deployment policy, or cost allocation materially improves the workflow.
Run a bakeoff for important recurring work
Take three representative tasks—easy, typical, and adversarial—and run the same contract through two plausible tools. Score output quality, time to acceptable result, source quality, edit burden, privacy and deployment fit, and total cost. Keep the winner for that workflow, not for every workflow.
5. Work well with Codex, Claude Code, and Google Cloud
Coding agents are most useful when they can see the repository, use its tools, and verify the result. They are least useful when asked to make a sweeping change with no local rules or proof.
- Put durable instructions in the repository. Record architecture boundaries, commands, style, risky areas, and the definition of done.
- Ask for one coherent vertical slice. A small end-to-end change is easier to test and review than a broad layer-by-layer rewrite.
- Name the verification commands. Type checks, unit tests, builds, migrations, and browser checks should not be left to guesswork.
- Keep permissions narrow. Reading, editing, deploying, sending, and deleting are different capabilities. Grant only what the current step needs.
- Review the diff and the behavior. Clean-looking code can still encode the wrong assumption.
- Checkpoint long work. Preserve decisions, completed steps, known failures, and the next test so another session can resume without reconstructing history.
Codex and Claude Code are agentic coding products: they provide a harness around one or more models so the model can inspect files, use tools, edit code, and run verification. A hosted model is not the same thing as that harness.
On Google Cloud, Claude Code can be configured to use Google Cloud’s Agent Platform, formerly Vertex AI, for model access. That path is useful when Google Cloud IAM, project billing, model versions, regions, and deployment controls should be centrally managed. Claude Code remains the working harness; the Google Cloud platform is the managed model and governance layer underneath it.
6. Treat the harness as part of the product
Harness engineering is the design of the system around the model: instructions, context assembly, tools, permissions, state, checkpoints, tests, observability, and recovery. The model supplies capabilities. The harness makes those capabilities reliable enough for a real workflow.
A production-worthy harness has at least six parts:
Agentic engineering is the broader practice of designing software and operations in which models can plan and act through tools. Our current stance:
- The model is a component, not the architecture. Keep model choice replaceable.
- Autonomy is earned. Start with supervised, reversible work and expand only from observed performance.
- Context is engineered. Retrieve and compress what matters instead of dumping everything into a prompt.
- Guardrails should be capabilities. It is safer to withhold a dangerous tool than to merely ask the model not to use it.
- Every important action should be attributable. Record inputs, tool calls, outputs, errors, approvals, and the final disposition.
- Failures become evals. A real miss is a test case for the harness, not just a prompt anecdote.
7. Match verification to consequence
Fluent output is not verified output. Increase the verification burden as the consequence of error rises.
| Consequence | Minimum verification | Human gate |
|---|---|---|
| Private, easily reversible draft | Read it; spot-check important facts. | Optional. |
| Internal decision support | Trace key claims to primary sources; recompute important numbers. | Decision owner reviews. |
| Code or data change | Inspect the diff; run deterministic tests; verify migration and rollback paths. | Repository or system owner approves material changes. |
| External communication | Check facts, audience, privacy, brand, and commitments. | A named human sends or publishes. |
| Money, access, legal, people, or production | Policy-specific checks, audit trail, and safe failure behavior. | Required accountable approver. |
An interim data rule
Until a portfolio company has an approved AI data policy, classify inputs as public, internal, confidential, or restricted. Public information may use approved general tools. Internal and confidential information should use the company’s approved enterprise environment and settings. Restricted information—credentials, regulated records, privileged legal material, sensitive personnel data, or customer secrets—should not enter an AI system unless the owner has explicitly approved that system and workflow.
8. Promote successful work deliberately
Most useful AI systems begin as one person doing one task well. Promote the workflow one rung at a time:
- 01 One-off Prove one bounded result.
- 02 Template Save the contract and a good example.
- 03 Skill Package inputs, outputs, instructions, and checks.
- 04 Agent Add tools, permissions, state, and recovery.
- 05 Automation Use a stable trigger; observe every run and exception.
- 06 Product system Add evals, release discipline, security, and an owner.
The aim is not maximum autonomy. The aim is the cheapest reliable system for the consequence of the work.
9. Put this into practice in 15 minutes
- Choose one real task due this week.
- Name its mode: Ask, Research, Create, Delegate, or Automate.
- Write the six-line work contract.
- Choose one starting tool from the map.
- Run the task and apply the right verification level.
- Record one thing the system misunderstood or could not do.
- If the work will recur, save the contract and result as the first test case.
10. Terms worth using precisely
- Model
- The learned system that predicts and generates outputs. It is a component inside a product or harness.
- Product
- The user-facing application—such as ChatGPT, Claude, Gemini, Gamma, or Canva—that packages models with interfaces, tools, storage, and policies.
- Agent
- A model-driven system that can choose and execute multiple steps through tools toward a goal.
- Tool
- A capability the system may invoke: search, a database query, file editing, a browser, an API, or deployment.
- MCP
- Model Context Protocol, a standard way for AI applications to connect to tools and context providers.
- Skill
- A reusable package of instructions, references, and sometimes scripts for a defined kind of work.
- Context engineering
- Selecting, structuring, and maintaining the information a model needs at each step.
- Harness engineering
- Designing the instructions, tools, permissions, state, verification, observability, and recovery around a model.
- Eval
- A repeatable test of system behavior using representative tasks, expected properties, and a scoring method.
- Agentic engineering
- Building software and operations in which models can plan and act through tools under engineered constraints.
Sources and further reading
- Gamma: AI presentations—prompt and document import, themes and brand, editing, presenting, and export.
- Anthropic: get started with Claude Design—beta availability, design systems, iteration, export, and handoff to Claude Code.
- Anthropic: Claude Design for presentations—brand-consistent, interactive HTML presentations and common deck workflows.
- Canva: AI presentation maker—Magic Design for Presentations, Brand Kit, collaboration, media, and reuse.
- Lovable: prototyping—working prototypes from tickets and documents, stakeholder testing, and GitHub handoff.
- Lovable documentation—full-stack web applications, editable code, GitHub sync, security, and operating scope.
- Anthropic: Claude Code overview—codebase context, multi-file work, command execution, verification, and integrations.
- OpenAI: how OpenAI uses Codex—codebase understanding, refactors and migrations, tests, task scoping, and repository context.
- OpenAI: deep research in ChatGPT—multi-step research across selected sources with a documented, cited report.
- Google: NotebookLM sources—supported source types, source selection, summaries, and source-grounded research.
- Anthropic: Claude Code on Google Cloud’s Agent Platform—setup, IAM, regions, model access, and version pinning.
- Google Cloud: use Claude models—managed Claude model access through Google Cloud.
- Anthropic Engineering: harness design for long-running agents—state, progress, and continuity.
- Anthropic Engineering: evals for AI agents—turning expected behavior into repeatable tests.
- Google Workspace: create presentations with Gemini in Google Slides—a Workspace-native presentation option.
Related DVx research
- How we build software across the portfolio
- How We Rebuilt QSR Around Multi-Agent AI
- Rebuilding our Access Control for AI Agents
- The agent doesn’t hold the data. It decides where to go get it.
- We stopped treating agent latency as one number.
Added official product and company marks to every task route so the tool map is easier to scan.
v1.2 · July 30, 2026
Replaced the generic tool table with a task-first routing atlas covering presentations, prototypes, coding, research, brand production, and governed model access. Added current product guidance, explicit switch points, and first-party sources.
v1.1 · July 30, 2026
Added the reliable-work loop, harness anatomy, and workflow-promotion diagrams to make the operating model easier to scan and teach.
v1.0 · July 30, 2026
First release. Introduced the five working modes, the six-field work contract, the task-based tool map, the DVx harness and agentic engineering principles, the verification ladder, and the workflow promotion path.