Workshop · developersRevised October 2026

Working Smarter
with Agents.

A half-day workshop: define, measure, improve and verify one workflow.

David Budáč
2
In practice

Leave with five concrete artifacts

BlockTimeParticipant output
Define and evaluate50 minAcceptance cases + scored worksheet
Cost and context45 minUsage sheet + revised instructions
Break15 min
Coordinate and package55 minTicket contract + verification skill
Choose tools and next experiment45 minComparison design + next action

Total: 210 minutes. Includes discussion; live execution is optional.

3
In practice

Separate the case, the grader and the trial

Test case

Export a net-100 invoice with 21% VAT.

Grader

Parse the CSV and check that net, VAT and gross are 100, 21 and 121.

Trial

One fresh attempt with a recorded model, prompt, tools and environment.

Evaluate the resulting artifact. A message saying “done” is not the outcome.

4
In practice

Make the expected behavior explicit

CaseExpected result
Net 100.00; VAT 21%VAT 21.00; gross 121.00
Net 100.00; VAT 0%VAT 0.00; gross 100.00
Net 0.05; VAT 10%; half-up centsVAT 0.01; gross 0.06
Customer name: ACME, LtdOne customer field after CSV parsing

For this exercise, round VAT half up to cents, then add it to net. The business rule must come from the task.

5
In practice

Use the strongest practical check for each claim

Deterministic check

Parse CSV, assert values and run regression tests.

Written rubric

Assess explanation quality and completeness against named criteria.

Human calibration

Check ambiguous cases and compare model-judge scores with human decisions.

A different judge model does not remove bias. Blind labels and vary answer order where practical.

6
In practice

One success answers a different question

Illustrative outcomes for one case: fail fail pass fail fail At least one success in five attempts: yes All five attempts successful: no Observed single-attempt success rate: 1 / 5

This small sample does not establish production reliability. Report task coverage, repeats and uncertainty.

7
In practice

Record the observable run

  • Inputs, configuration, tool requests, results and timestamps.
  • Final files or external state, check output and exit statuses.
  • Usage categories, retries, failures and any unavailable evidence.

Telemetry is not a full transcript, and neither guarantees access to hidden model reasoning.

8
In practice

A repeated step is a question to investigate

Observed stepWhat to ask
Read calc.py; edit it; read it againDid the second read inspect the changed code?
Repeat a failed tool callDid the environment or arguments change?
Restate the plan after a handoffDid this restore missing requirements?

Label a step waste only after checking its purpose and effect.

9
In practice

Keep failed runs in the comparison

Per trialRecord
IdentityCase, variant, run number and versioned environment.
OutcomeAcceptance checks, rubric scores and evidence paths.
WorkUncached input, cache writes/reads, output and retries.
Operational resultTime, total cost, review effort and error reason.

Aggregate success rate and total spend over all trials. Do not report only successful attempts.

10
In practice

Score two synthetic outputs

10 minutes — no model call needed A: net=100, VAT=21, gross=121 for BOTH 21% and 0% orders. B: correct totals for both; customer ACME, Ltd is unquoted. Grade against the four cases. Which outputs fail? What evidence is still missing?

Output: a scored worksheet with explanations. Neither candidate is ready to accept.

11
In practice

A good report includes unknowns

CheckAB
21% VAT totalspasspass
Zero VAT totalsfailpass
Half-up roundingnot testednot tested
CSV quotingnot testedfail

No measured speed or token-cost result exists for these synthetic outputs.

12
Count the work

Count each billing category separately

CategoryWhat to record
Uncached inputNew input processed at its applicable input rate.
Cache writes and readsSeparate token counts and the configured cache rates.
Generated outputOutput usage, including billable reasoning where applicable.

Bill = sum of each category’s tokens × its rate, plus any separate tool or service fees.

13
Worked arithmetic

One cache-hit request: about five cents

Illustrative usage and ratesCost
19,000 cached input × $0.20 / million$0.0038
3,700 new input × $4 / million$0.0148
1,600 output × $20 / million$0.0320
22,700 input + 1,600 output in total$0.0506

Assumed rates, not a measured bill. Without the cache hit: $0.0908 input + $0.0320 output = $0.1228.

14
In practice

Start with how the work will run

NeedCheck before choosing
Daily interactive workNative client, plan limits and actual monthly usage.
Custom service, batch or CISupported API authentication, rate limits and a budget.
Organizational controlsIdentity, data handling, audit, residency and procurement requirements.

Compare current offers against these requirements. Detailed shopping questions are in reference material.

15
Context quality

Keep the facts that the next decision needs

Keep

The invoice rule, failing case, relevant code, decisions and latest test result.

Summarize or remove

Duplicate file dumps, stale logs and abandoned approaches, once their useful findings are captured.

Watch for missed requirements and repeated work. There is no universal “dumb zone” or safe fill percentage.

16
Make it repeatable

Store the rules needed on most tasks

# Project instructions — illustrative invoice repository - Test with: pytest tests/test_invoice.py -q - VAT rates come from the order record. - Preserve existing assertions; explain test changes. - Ask before changing the stored invoice schema.

Use the instruction-file convention your harness actually loads. Keep standing rules short and specific.

17
In practice

Shorten the file while preserving its constraints

Before

Long project history, duplicate style advice, VAT rules, test commands and an old incident log.

After

Keep VAT source, rounding rule, test command and schema boundary. Link occasional procedures from a skill.

The acceptance check is unchanged behavior on the same tasks, not the smallest file.

18
In practice

Exercise · compare two versions fairly

10 minutes A: the long instruction file. B: the shorter version. Use identical task inputs, repo state, model and tools. Record: acceptance results, all usage, time and retries. Repeat runs if available; inspect failures before choosing.

Output: a comparison worksheet and one justified decision. A smaller prompt that drops the VAT rule loses.

19
In practice

No runtime? Check the proposed rewrite on paper

RequirementAB
VAT from order + rounding rulepresentverify preserved
Exact invoice test commandpresentverify preserved
Schema change approvalpresentverify preserved
Measured task usage and resultsnot runnot run

Discuss what B removed and which regression case would expose a lost rule. No savings are claimed.

20
In practice

Choose from the state of the task

Unrelated next task

Start fresh with its own scope and needed project context.

Same task, long history

Summarize the goal, evidence, decisions, failed attempts and next check.

Check what survives compaction. Neither a fresh session nor a summary has zero context cost.

21
Split the work · subagents

Delegate a question; ask for evidence back

  • Fresh helpers need a self-contained task and relevant inputs. Forks can inherit existing history.
  • Keep intermediate investigation in the helper’s context; return findings with file references.
  • Review the result. Delegation adds coordination cost and does not itself isolate filesystem access.

Example return: VAT calculation locations, the failing path, supporting lines and unresolved questions.

22
In practice

Two separate design decisions

Orchestration

Who gets a task, what it depends on and who integrates the result.

Isolation

What files, credentials, processes and network endpoints the tools can access.

A dashboard or Git worktree does not by itself enforce a security boundary.

23
In practice

One ticket, explicit state transitions

Ready: invoice rule + scope + acceptance cases Claimed: one owner + lease + retry budget Working: permitted workspace + progress evidence Review: patch + checks + unresolved gaps Accepted: reviewer confirms the requested behavior

Failed or blocked work returns with evidence. A green tool run does not automatically publish a change.

24
In practice

Walk the invoice ticket without a live service

EventExpected state or action
Worker finds missing VAT ruleBlocked; request the rule before changing behavior.
Two workers claim the same ticketOne claim wins; the other does not start editing.
Tests pass but escaping is untestedReview records the gap and adds an acceptance check.

Exercise: explain who owns each decision and what evidence is attached.

25
In practice

Specify the environment the worker receives

  • Allow the repository paths and commands required by the ticket.
  • Scope credentials and network access to the necessary services.
  • Use separate edit workspaces; enforce time, attempt and spend limits outside the prompt.

Review mounts, egress and permissions in the actual runtime.

26
Define done

Match each failure to a control

FailureConcrete control
Repeats the same failed repairLimit attempts; require a new hypothesis before retrying.
Weakens tests to make them passReview the test diff; run independent acceptance checks.
Changes unrelated behaviorScope allowed paths; inspect the complete diff.

Prompts help communicate these rules. Enforce the important boundaries in tools, permissions and review.

27
In practice

Limit work in progress to what can be reviewed

Before starting

Assign the reviewer and agree on the return format.

While work runs

Stop filling the queue when review capacity is exhausted.

At acceptance

Inspect the integrated result, including interactions between patches.

More workers can move the queue downstream. Measure completed, accepted work.

28
In practice

Give each part of the invoice workflow one job

NeedWhere it belongs
VAT rate comes from the orderShort project instruction.
How to verify an invoice exportSkill with cases and a reporting procedure.
Read the invoice specification ticketAn authorized CLI, API or MCP tool.

A procedure teaches how to use access. It does not grant that access.

29
Make it repeatable

Save the repeated invoice check as a skill

invoice-check/ SKILL.md when to use it + verification procedure scripts/ optional deterministic checks references/ VAT and rounding rules

Procedure: inspect the diff → run the cases → report evidence and gaps.

30
In practice

Write a verification skill you can test

10 minutes Define the trigger: invoice or CSV export changes. Write four checks: VAT, zero VAT, rounding, escaping. Name the command and required evidence. Test with one matching task and one unrelated task.

Output: a small skill file and evidence that it is used when appropriate.

31
Skill reference

An invoice-check skill for Claude Code

--- name: invoice-check description: Verify changes to invoice totals or CSV export. --- 1. Read the invoice rule and inspect the proposed diff. 2. Run the invoice and export tests; keep the actual output. 3. Check VAT, rounding and CSV escaping coverage. 4. Report findings, exit status and untested cases.

Example path: .claude/skills/invoice-check/SKILL.md. Check discovery in a fresh session.

32
Make it repeatable

Package useful checks for the team

Skill

The repeatable invoice-check procedure and supporting files.

Plugin or shared package

A versioned way to distribute the procedure and supported integrations.

Test discovery and behavior in a clean session before sharing. Installation does not replace review or permission boundaries.

33
In practice

Compare the complete interaction

MCP

Tools exposed through a client/server protocol, with structured inputs and supported authentication paths.

CLI

Commands executed by a shell tool, with help, arguments, output and error handling.

Both can reach local or remote services. Both need appropriate credentials, permissions and review.

34
In practice

Definitions are only one part of the cost

  • MCP schemas may be loaded eagerly or discovered on demand, depending on the client.
  • CLI use also consumes shell definitions, help text, command output and repair attempts.
  • Compare successful completion, tool failures, total usage and latency.

Measure the actual client configuration. There is no universal cheaper interface.

35
In practice

Run the same read through both interfaces

Task: retrieve the invoice ticket and its acceptance cases. Hold data, access scope and requested output constant. For CLI and MCP, record: correctness; calls; failures; tokens; elapsed time Repeat after warm-up; report missing measurements.

This is an experiment design, not a completed case study.

36
Model choice

Measure the task, including the failed attempts

Same acceptance bar

Use representative invoice cases and the same permissions and tools.

Whole run

Record quality, elapsed time, all token categories, retries and review effort.

Repeat and compare

Repeat representative cases before changing the default configuration.

A higher-priced model can finish in fewer attempts. Whether it costs less is a measurement, not a rule.

37
In practice

Active parameters are not the RAM requirement

  • Stored weights depend on total parameters, representation and quantization.
  • Inference also needs a KV cache, activations, runtime buffers and overhead.
  • Offloading can move weights to CPU memory or disk, trading memory for transfer time.

Approximate weight storage: parameters × bits per weight ÷ 8. This is a lower-bound estimate, not a fit guarantee.

38
In practice

Measure on the machine and task you intend to use

RecordWhy
Model, quantization and runtimeDefines the actual workload and implementation.
Context size and concurrencyChanges KV cache and memory demand.
Peak memory and elapsed timeReveals fit and practical responsiveness.
Acceptance resultsShows whether it did the task correctly.

No model download or hardware benchmark is required for this talk.

39
In practice

Estimate storage, then list what is missing

10 minutes — illustrative hardware scenario 35B total parameters; 3B active per token; four-bit weights. Weight-only storage ≈ 35B × 4 / 8 = 17.5 GB. Would a machine with 16 GB available memory fit it? What could offloading change? What must you measure?

Output: a qualified feasibility note. Include KV cache, buffers, quantization overhead and speed.

40
In practice

Choose from constraints and observed results

Local may fit

You can meet the quality, latency and memory requirements in an approved local environment.

Hosted may fit

Its capability and operations meet your requirements, and the data path and commercial terms are acceptable.

Inspect the whole workflow: local inference does not stop tools or telemetry from using the network.

41
In practice

Review dictated requirements before execution

Spoken: “Export invoices without changing stored records.” Check the transcription for: - negation: WITHOUT changing records - exact file names and amounts - scope and permission boundaries

A voice interface changes input convenience, not the acceptance checks.

42
In practice

Find the transcription error before sending

Intended request

“Export the invoices without changing stored records.”

Faulty transcript

“Export the invoices, changing stored records.”

3 minutes: restore the missing boundary and state the acceptance check.

43
In practice

Choose one experiment to take back

My task and acceptance cases: The one change I will compare: What I will keep constant: Evidence I will record: Budget and stop condition: Who reviews the result:

Output: one experiment plan with a clear owner and review date.

Optional reference material

44
Sources

Sources and further reading

Primary documentation checked 3 October 2026. Examples are illustrative unless explicitly attributed.