Build a support-answer harness that knows when to stop

A PDF invoice is a good example of where AI and ordinary rules have different jobs. The model can help read an inconsistent document. Arithmetic, duplicate checks and approval rules should not depend on a fluent explanation.

An invoice-intake harness separates those steps. The first version should prepare records for review, with no authority to pay suppliers or change bank details.

Define the record you need

Start with supplier name, invoice number, invoice date, currency, net amount, tax amount, total and source file. Ask for missing or unreadable fields to be marked explicitly. Preserve the original document for the reviewer.

Use a small set of synthetic invoices for the first test. There is no need to expose real account details while deciding whether the workflow understands your required fields.

Build the checks outside the model

A visual workflow might be: dedicated upload folder → document extraction → fixed output fields → arithmetic and duplicate checks → exception queue or review-ready record.

Check net plus tax against total using ordinary decimal arithmetic with an explicit rounding tolerance. Check likely duplicates using supplier identifier, invoice number and other relevant fields; do not rely on the filename alone. A renamed attachment can still be the same invoice.

A structured parser can help enforce the expected field layout. It cannot establish that the document is authentic or that the extracted values match the original. Read n8n’s structured-parser documentation.

Give exceptions a useful destination

If the currency is missing, the sums do not reconcile or two documents appear to represent the same invoice, route the record to a named reviewer. Include the failed check and the relevant source, rather than a generic error message.

Treat bank-detail changes and payment approval as separate processes owned by the finance team. A model-generated match or a well-formed record is not approval to move money.

Test behaviour at the boundary

Try a clean invoice, a duplicate with a new filename, a blurred total and a credit note. Decide how each should be handled before evaluating the workflow. A credit note must not silently become a positive invoice because the template expects a total.

Measure extraction corrections, duplicates missed and reviewer time. Include model usage, retries and exception handling when calculating cost per accepted record. A low-cost model may be enough for some documents; that is a result to measure, not a promise.

This harness can often be assembled from visual workflow components and existing document services. Connector availability and document quality determine how much configuration is needed. The practical benefit is a consistent intake process whose uncertain cases remain visible to the people responsible for the accounts.

“We should probably ask Maya next week.” That sentence can become “Maya will deliver next week” in a careless meeting summary. The words are similar; the commitment is different.

A meeting-action harness should preserve that distinction. Its goal is a reviewed action record, not an impressive-looking task list after every call.

Decide what counts as an action

Define the fields before choosing the model: action, explicitly agreed owner, due date if stated, status and transcript evidence. Use separate statuses for agreed, proposed and unresolved.

If no owner accepted the task, leave ownership unresolved. If someone says “Friday”, use the meeting date and time zone to propose an interpretation for review rather than silently assigning a date when the context is ambiguous.

Keep the relevant transcript excerpt attached. A reviewer should not need to replay the whole meeting to discover why a task exists.

Connect extraction to review

The visual workflow is: approved transcript arrives → extract action candidates → validate fields → route unresolved items to review → create only approved tasks. Use your organisation’s rules for recording, access and retention before connecting real meetings.

Human-review features in a workflow builder can pause a tool action for a decision. They are useful when turning extracted suggestions into changes in another system. See n8n’s human-review example.

The meeting chair or relevant owner should review the commitments. An automatically assigned task can create confusion even when it is technically easy to undo.

Plan for retries and corrections

Give each approved action a stable identifier linked to the meeting and source item. Check whether that identifier has already been written before creating a task. If a run fails halfway through, rerunning it should not create a second set of commitments.

Keep a correction route. If the owner or deadline changes during review, save that decision rather than asking the model to reinterpret the entire meeting until it produces the desired answer.

Test disputed language

Use a short fictional transcript containing a proposal, an explicit agreement, a rejected idea and a changed deadline. Decide the expected actions manually, then compare the workflow’s output. Count invented owners and dates separately from harmless wording differences.

This is a practical no-code harness when your transcript and task tools have suitable connectors. It still requires configuration, permissions and maintenance. The reliable target is consistent treatment of evidence and approval, not identical prose on every run. The most valuable output may be one agreed task and two clear questions.

A model can turn a short product note into an impressive launch story. It can also add a customer outcome, a feature or a statistic that nobody approved.

A content harness should make that expansion visible. Its job is to adapt an approved story to different channels while preserving the facts and keeping publication under editorial control.

Define the source of truth before the tone

Create a brief form with the audience, purpose, approved facts, evidence links, available product features, prohibited claims and call to action. Separate factual inputs from stylistic preferences.

For example, “the tool exports a CSV” is a product fact. “Make the copy confident and direct” is a writing preference. The second instruction must not turn the first into “exports to every business system”.

If you have no customer result or performance measurement, leave that field empty. A strong piece of content can explain a useful workflow without inventing a case study.

Save the channel rules once

A visual workflow can read the approved brief, generate a blog outline and social drafts, check length and required fields, and place the results in an editorial queue. Use saved channel templates for structure, tone and formatting.

Keep a list of claims beside each draft and require a link back to the relevant brief item or source. Rules can check whether a link or required field exists; an editor still needs to judge whether the evidence supports the wording.

A structured-output component can help keep the same fields across runs. It does not verify the truth of the prose. See n8n’s parser documentation.

Put publication after approval

Generate drafts first. A person checks factual accuracy, tone, confidentiality and image suitability. Keep the approval attached to the specific version; later edits should not inherit it automatically.

For images, define the visual system separately: palette, aspect ratio, typography and whether people are illustrative or real. A generated face should not imply a customer testimonial or an employee identity.

Test the temptation to embellish

Use a brief with no statistics, one with an unresolved feature and one with an explicitly prohibited claim. The expected output should preserve those gaps. If the model fills them with attractive inventions, the workflow is not ready for unattended drafting at scale.

You can build much of this with forms, tables and visual automation connectors. You still configure instructions and maintain the templates. The harness removes repetitive briefing and adds reviewable boundaries; it does not remove editorial responsibility.

The useful measure is time to an approved, accurate draft across channels. Producing more words is easy. Preserving the story is the work.

“Which quote is best?” is an easy question to ask a model and a difficult question to answer responsibly. One supplier includes delivery, another excludes it and a third quotes a different quantity. A fluent summary can hide those differences.

A model harness makes the comparison process explicit. Here, the harness is a saved workflow around the model: approved inputs, fixed fields, validation, evidence and a human decision. You configure it once and reuse it, instead of reconstructing the task in a chat every time.

Fix the comparison contract

Choose the fields with the person who will make the decision: supplier, item, quantity, unit, currency, net price, delivery cost, lead time, exclusions, quote expiry and source reference. Keep missing values empty and give them an explicit “not supplied” status.

A quote for 100 units must not silently become comparable with one for 10. Likewise, missing delivery cost is not zero delivery cost. Put incompatible units and currencies in an exception column rather than asking the model to guess a conversion.

Assemble a visual workflow

A first no-code design is: upload form → document extraction → structured fields → required-field and consistency checks → comparison table → review notification. A builder such as n8n can supply visual workflow components; the exact document and storage connectors depend on your systems.

Save the extraction instructions inside the workflow. They still exist, but the user no longer needs to write them for every batch. Use a spreadsheet or deterministic calculation step for arithmetic after a person verifies the relevant commercial assumptions.

n8n documents a Structured Output Parser for schema-shaped output. A schema helps enforce format; it does not prove that extracted prices or terms are correct. Read the parser documentation.

Review differences before ranking

Try three invented quotes: one complete, one missing delivery cost and one with a different unit. The expected behaviour is an honest comparison with exceptions, not a winner on every run.

Keep the original documents beside the table. The buyer decides which exclusions matter and whether clarification is needed. Do not let this first workflow place orders or negotiate terms.

If you want a score, define and approve the weighting outside the model and show the calculation. An unexplained AI ranking makes the process harder to audit.

The repeatable part is the comparison standard: the same fields, checks and decision boundary. Wording may vary, extraction can still fail and a stronger model may sometimes help. Measure field accuracy and review time on representative quotes before claiming savings. A harness is valuable when the reviewer can see what was compared and what is still unknown.

A long coding session can finish with a surprisingly vague note: “Most of the feature is done.” The next session then spends time rediscovering what changed, what passed and what is still a hypothesis.

A useful handoff is smaller and more precise. It should let another developer—or another agent session—verify the current state before continuing.

Save state and evidence separately

Ask for the task objective, current branch or revision, changed files, checks actually run and unresolved work. Include links or paths to the relevant artifacts. Do not paste the whole conversation into the repository.

For example: “The export now preserves column order. The sample-data regression test passed. The large-file path has not been exercised. Next step: run the existing performance fixture before changing buffering.” That is more useful than a confident claim that the export is complete.

Distinguish observed facts from proposed next steps. “The test timed out” is an observation. “The database may be unavailable” is a hypothesis until checked.

Resume by checking the repository

At the start of the next session, have the agent inspect the working tree and compare it with the handoff. Someone may have changed a file or committed a different version. The saved note is a guide, not a replacement for current evidence.

Keep secrets, customer data and unnecessary logs out of the handoff. A test command and a concise result are usually more useful than a full terminal transcript. Preserve detailed diagnostics separately when they are needed and safe to retain.

Give the next step a boundary

A strong next step names both the action and its purpose: “Verify that a duplicate request does not create a second record.” It should not quietly authorise a production deployment or an unrelated refactor.

Record any decisions that must remain with a person, such as choosing a data-retention policy or accepting a breaking API change. That stops a later session from treating an unresolved business choice as implementation detail.

Anthropic’s context-engineering guidance discusses maintaining useful information over longer work. This handoff pattern applies that idea to a reviewable engineering artifact. Read the guidance.

Try a five-minute handoff at the end of your next agent session. On resumption, measure how long it takes to identify the actual state and next useful action. The best handoff reduces rediscovery without pretending the work is more complete than it is.

Using the most capable model for every coding step is a simple default. It may also spend more than the task needs. Sending everything to a smaller model can create the opposite problem: cheap attempts that become expensive to review and repair.

A useful experiment is to route work by observed performance on your repository. Keep the acceptance standard fixed while changing which model does the work.

Separate the tasks before comparing models

A mechanical rename, a failing-test diagnosis and a change to an authentication boundary are different jobs. Group a few representative tasks by type and consequence. Do not assume a model that formats documentation well will make good architectural decisions.

For an initial trial, choose low-impact changes in an isolated branch. Record the starting revision, task brief and checks. Run comparable tasks under controlled conditions and review the results using the same criteria.

Avoid sending confidential code to a service your organisation has not approved. Model selection includes the deployment and data-handling arrangement, not just capability.

Define escalation before the retry loop

A reasonable experimental policy might allow one attempt and one bounded repair for a narrow task. If a required check still fails, stop and request a human decision or route to a more capable model with the failure evidence. The exact limit is a design choice to test, not a universal best practice.

Do not let the model’s own confidence determine acceptance. Use the actual test results, diff, requirement coverage and human review. A stronger model can also be confidently wrong.

Anthropic describes routing work between specialised paths, including models with different capability and cost. The practical extension is to test that routing against your own accepted changes. Read the routing discussion.

Count the whole bill

For each accepted change, record model usage, repeated context, tool runs and review time. Track rejection and escalation rates as well. Lower token cost is useful only if the total workflow still meets the quality bar.

Some tasks may be cheaper with ordinary scripts. Some may justify the stronger model immediately. Others may benefit from a small model preparing context for a human or a stronger model.

I would keep the first routing table short and revisit it when the model, codebase or task mix changes. The outcome to optimise is a maintainable accepted change, not the cheapest individual response.

AI can generate the appearance of a large product quickly. Screens, routes and components accumulate. The difficult question is whether one real user action works from beginning to end.

A useful coding tactic is to ask for a thin vertical slice: one narrowly scoped path through the interface, application logic and persistence. It should be small enough to review and real enough to expose integration problems.

Choose one observable outcome

Imagine a simple client portal. Start with “an authorised user can create one project and see it after a page reload”. That outcome connects input, validation, storage and retrieval. It is more informative than generating every dashboard screen before any data survives a refresh.

Write the acceptance checks first. What fields are required? What happens if the name is empty? Can another user see the record? What should a failed save look like?

Ask the coding agent to implement that path using the existing project conventions. Keep new dependencies and architectural changes justified by the slice, rather than by a speculative future roadmap.

Make temporary pieces explicit

Sometimes a prototype needs a mock service. That is fine if the mock is visible and the limitations are recorded. Do not call a workflow integrated when it is actually displaying local sample data.

Ask the agent for a short list of real integrations, temporary stubs and missing production work. If authentication is simulated, say so before anyone mistakes the demonstration for a deployable product.

Exercise the whole path

Run the action in the UI, reload the page and inspect the stored result. Test a relevant failure case. Automated checks can cover important behaviour, but seeing one success screen alone does not establish persistence, permissions or recovery.

Once the slice works, expand one dimension at a time: another field, an edit operation, a second user role. Each addition should preserve the working path you already verified.

This approach gives the agent feedback while the change is still understandable. It also gives a founder or product owner something meaningful to react to: a real outcome with visible tradeoffs.

For your next AI-built feature, replace “build the portal” with one end-to-end user action and a few checks. Measure time to a reviewed, working slice. A smaller first delivery can reveal the expensive assumptions before they spread through the rest of the product.

A long prompt can look thorough while hiding the few facts that matter. If the agent receives old requirements, unrelated logs and several competing implementations, it may spend its effort reconciling noise.

For a bounded coding task, I would start with a small context pack. Its purpose is to make the change legible: what should happen, where the relevant behaviour lives and what must remain true.

Put five things in the pack

Include the desired user outcome, the likely entry points, one representative example, the constraints and the checks that define completion. Link to actual files rather than copying large sections that can go stale.

For a CSV export change, that might mean the export handler, the shared date formatter, a sample input row, the required column order and a test covering the output. Add a constraint such as “preserve the existing download endpoint”.

Separate durable repository conventions from task-specific instructions. The project’s normal build and test commands belong in a maintained repository guide. The exact export columns belong in the task brief.

Let the agent request context with a reason

Do not forbid exploration. Ask the agent to inspect the relevant files and explain when another dependency matters. A short context pack should be a useful starting point, not an artificial blindfold.

If the implementation crosses a shared component or data contract, the agent needs that context too. Conversely, a folder full of archived design notes should not automatically enter every request.

Anthropic’s context-engineering guidance treats context as a limited resource that needs active selection. That supports this practical habit: keep the working brief focused and retrieve supporting detail as the task develops. Read the guidance.

Measure the result, not prompt length

Try the same kind of small task with your usual brief and with a context pack. Compare clarification rounds, unrelated file changes, missed constraints and review effort. A shorter prompt that omits a critical dependency is worse than a longer useful one.

Before accepting the result, check whether the agent used the current code and requirements. Generated notes can become stale just like human documentation. Record the relevant revision when you save a reusable task example.

The aim is enough context for a good decision, with a clear route to more. This makes the brief easier for both the agent and the human reviewer to understand.