hamsa softwareTHE HAMSA SOFTWARE BLOG / WEEKLY NOTES
Notes on AI, connected systems and the decisions behind useful software. What works, what gets awkward, and what we can learn from the difference.
Subscribe via RSSTHIS WEEK / AI TOOLING
An assistant that drafts invoice reminders needs three read permissions in Xero. Here is a one-page review of what it can read, change and refuse, and why a payment scope turns a customer’s email into a ledger entry.
EXPLORE THE COLLECTION
118 articles across AI, automation, integrations, and thoughtful engineering.
118 articles
An assistant that drafts invoice reminders needs three read permissions in Xero. Here is a one-page review of what it can read, change and refuse, and why a payment scope turns a customer’s email into a ledger entry.
A saved replacement, a running service and an attacker’s existing access can change at different times. Railway’s guidance explains why that matters; PingCAP and PHP show where the next job differs.
An Oprindo sample had a matching asset hash and a valid signature, alongside an untrusted credential result. The useful story is in those separate answers.
You need the repository; the host keeps the reusable key. WardOS checks what the agent asks to do—and whether a passing test still describes the files being reviewed.
A small Tamperward experiment produced two green test runs for the wrong reason. Comparing them with the original checks exposed the difference.
Separate observed results, inference and release authority, so an attractive score cannot quietly approve a different product.
Computer use needs an observation contract for account, object and outcome, especially when a visible click produces only partial completion.
Retire intake, accepted jobs and external authority in a deliberate order, so a late event cannot revive an obsolete process.
Repairing a consumer makes replay possible. Current state, dependencies and recovery admission decide whether it is still appropriate.
Resolution, crop and reserved space solve different image problems. Design all three around what the reader needs to see.
Version the resolved configuration around an AI response so comparisons, investigations and rollback refer to the system that actually ran.
Enforce task limits through atomic reservations and repeat-safe settlement, including the uncomfortable case where a timed-out operation may still be spending.
Historical work needs a population boundary, revision policy and crash-safe checkpoint strategy before its final page can mean done.
Local inference offers a different operating boundary. Evaluate the completed task, data routes and maintenance responsibility before buying into it.
Freshness follows source dependencies through indexes, summaries, caches and in-flight answers—not just the original URL.
A readable table preserves relationships between values, row labels, column headings and actions across different ways of reading.
Bind an assistant’s approval to the action, target and material revision, then enforce that binding when the write happens.
External instructions can gain apparent legitimacy through summaries and approval screens. Keep the proposal’s origin and actual effect visible.
Reconcile transactions, payouts and bank entries at their own boundaries. A net total needs an explanation, not a forced match.
A shadow comparison exposes differences. Independent rule examples explain whether those differences are bugs, corrections or changed assumptions.
A useful waiting screen represents a durable job: accepted work, defensible progress, cancellation and a result you can return to.
Retirement work needs both declared consumers and observed usage. A quiet seven-day dashboard cannot account for a monthly dependency.
Business identity and diagnostic identity have different lifetimes. Connecting them makes the waiting between systems visible.
Current decisions, scoped memories and conversation history do different jobs. A changed site visit shows why the distinction matters.
An off switch cannot restore a contract that new writes have already changed. Plan reader and writer compatibility across the transition.
A stock feed due at 09:00 shows why deadlines, missing evidence and recovery belong in the alert rule itself.
A citation proves where a sentence came from. It does not settle which source governs the decision.
An unchanged API schema can still alter a weekly report. Define events, corrections and compatibility from the consumer’s side.
Readable error text is only the beginning. Three failures show how focus, retained input and the next action complete the recovery.
A model launch invites a paired migration experiment. The revealing result is often the case that got worse.
A manual fallback needs a transfer of control. A paused worker, a stale claim and an external booking show why.
A service-desk case set separates uncertain wording, missing evidence, exploratory research and absent authority—four reasons a workflow can stop, with different architectural answers.
A worked 120-call budget shows what an import costs interactive work, why retries consume the same capacity and how completion promises change with the scheduling rule.
A fixed-discount example, selected wrong implementations and an executable fixture show what generated tests can establish—and what they can agree to misunderstand.
A maintenance brief needs seventy-five reads whichever interface performs them. Tool discovery changes what the model sees; it does not automatically reduce the work behind it.
Thirty daily exceptions and eighteen review slots create a growing backlog. A worked capacity ledger shows what it takes to recover before waiting changes the job.
Twelve synthetic invoices reveal the trade between automatic coverage, unsupported accepted values and the review work an extraction policy creates.
A worked viewport budget and a reference-return fixture reveal how navigation, promotion and source checking compete with sustained reading.
A lost response leaves the payment outcome unresolved. A worked attempt ledger follows provider evidence, concurrent updates and fulfilment recovery.
A connector can move between assistants while changing the identity behind the request. A worked template-service contract separates portability from permission.
A generated answer can be quick while review, repairs and maintenance absorb the saving. A one-week enquiry model follows the human work before asking what value was created.
Constitutional Classifiers++ combines contextual checks with selective expensive review. An original cascade example explains why escalation, refusal, missed cases and compute overhead must not be treated as the same result.
A permitted answer for Alice is not a permitted cache hit for Ben. Revocation also reaches search indexes, old conversation context and links, where a retrieval-only check can be bypassed.
An old credential has eleven quiet months of logs and an annual job just outside the window. A retirement inventory shows how to remove unnecessary access without guessing what still depends on it.
No completed jobs might mean no incoming work, a stalled process or lost monitoring. A small state model separates those possibilities before asking someone to respond.
A dependency can install cleanly and return the wrong business meaning. A fictional normalisation change shows where an application contract test earns its place in routine upgrades.
A neat line from file to done can hide the decision that matters. Four mapping cases show how to make a diagram explain a contract rather than merely decorate it.
A payment-to-access join would revoke a trial, misunderstand refund grace and overlook duplicate grants. A six-member cutoff example shows how to reconcile the business rule instead.
A card that looks tidy at the default settings can hide instructions when text spacing changes. An identical-text specimen makes the layout decision and its repair inspectable.
A useful runbook says how to recognise the case, what evidence permits the action, when to stop and what proves completion. A CRM timeout gives those instructions something concrete to do.
Two reviewers can disagree because one is naming the queue and the other is naming every issue. Six messages reveal why changing the model cannot resolve an undefined task.
An importer rejects some rows after a change. A synthetic incident record shows how a configuration, an input feature and a failed mitigation can produce a better explanation than “bad deployment”.
Adding a JSON property can leave one reader unchanged, make another reject the response and shift a third consumer’s CSV. Compatibility depends on what the recipient actually does.
A workflow can include branches, judgement and AI-written drafts. The useful reason to add an agent is that evidence must change the plan, not that one input is inconvenient.
Sending a case to someone is different from their accepting responsibility. A versioned handoff shows how to keep work owned while offers expire, context changes and old notifications return.
When two fields contain the same email address, the values cannot tell you which sends invoices and which sends delivery updates. Labels, hints and errors each have a different job.
Claude Code’s checkpoint launch made experimentation easier. A catalogue-export example shows why restoring a source file is only one part of returning a workflow to a known state.
A primary source can establish a release date, report a case and make a vendor judgement. Those are different kinds of evidence, and the sentence beside the link needs to say which one it uses.
A stale-save warning protects the record only halfway if it throws away the person’s draft. A three-way quote example shows how to preserve edits without silently choosing a new commercial meaning.
A fast request and a fast worker can still leave a customer waiting. Two equal-duration order histories show how queue time, execution and missing evidence lead to different investigations.
Wednesday’s successful run does not prove Tuesday’s work happened. A period ledger makes missed work selectable, catch-up deliberate and completion something more useful than a green scheduler.
Sending easy work to a smaller model can save money. A hundred-task example shows how the router’s mistakes, detection and repair can change that conclusion.
Retrying a purchase, editing its basket and deliberately buying the same thing again can look remarkably similar to a request logger. The intent model has to distinguish them.
A warm accent can make a good background and a poor small-text colour. Five calculated pairs show how to preserve a palette while repairing the information people need to read.
GPT-5’s arrival was a reason to run a useful trial. An export-support reply shows why factual restraint, practical help and a promise the team can keep need separate attention.
Follow a recipient change from external text to a proposed tool call, and see where a useful assistant needs a boundary outside its prompt.
A dead-letter queue can give a failed message another journey without making its payload correct, its outcome known or its business action new.
A reassuring summary cannot tell you whether a validator preserves old identifiers, rejects trailing text or understands the contract. Eight small inputs can.
Three small discounted items produce 15p when each line is rounded and 14p when the total is rounded. Follow the difference into a provider payload and a partial refund.
An assistant finds travel reimbursement and an equipment form, then invents a home-monitor rule between them. Four source-and-question cases show a more useful response.
An old report and its replacement both show £200. Comparing six underlying records reveals two differences that the matching total has concealed.
Follow a purchase request whose destination changes while the reviewer is reading it, and the server rule that keeps the final action tied to the decision.
Two routing policies, one small teaching dataset: the more accurate policy misses critical requests, while the other needs more capacity than the team may have.
When a late supplier acknowledgement arrives after the customer asks to cancel, one status field is not enough to describe what the business knows and wants.
A controlled specimen puts the same paragraph, reference code, figures and completed field in two font stacks, so the decision has something concrete to rest on.
The May 2025 launch promised stronger sustained coding. Here is a concrete way to test the work left behind, using two patches and six independent contract cases.
Three deliveries can turn a paid booking back into a pending one and send two welcome messages. A worked projection shows where the interpretation goes wrong.
A worked restart manifest: distinguish completed manual work, an uncertain send, a changed record and an untouched enquiry before turning automation back on.
An extractor finds a valid date on an invoice and assigns it to the wrong field. The mistake survives a format check; following the cited line explains what the next check needs to establish.
A late import has three unresolved records with three different meanings. The useful runbook starts with a current observation, then makes authority, escalation and closure explicit.
An outbox preserves an unfinished obligation. A worked crash ledger shows what that buys, where duplicates remain and why the receiver needs its own boundary.
An illustrative batch cost breakdown separates delayed notification, repeated attempts and cost per useful completion.
A six-case onboarding-rule diff shows which expectations change, which remain valid and why old and new scores need different task identities.
Plan P7 changes one still-matching product, records one conflict and leaves a newly matching product untouched.
A two-account preference example separates storage, validation and current access, including the case where an old ETag must not produce 304.
A constructed write-permission failure shows how controlled comparisons change the next decision without proving more than their evidence supports.
A twelve-step sequential controller separates repeated evidence, hard limits, blocked access and the work needed to hand over.
A bounded GBP/JPY converter shows why currency, scale and source representation must survive each interface, even when the arithmetic is exact.
A retained eighty-word enquiry and one rejected email expose why error recovery needs state, labels, associations and a usable correction route.
Five mixed-version records expose the difference between valid JSON, representable unknown states and safe status-dependent actions.
A filter-retention brief becomes reviewable when Back, reload, copied links and account switches have explicit expected outcomes.
A three-event comparison proves why equal row counts and equal totals can conceal both a duplicate and a missing event.
A reader/index compatibility matrix shows why a release flag can remain operable after the old route stops being a valid fallback.
A five-record traversal shows exactly how deletion causes an omission, insertion causes repetition and a premature checkpoint loses committed progress.
A three-sentence customer reply becomes a concrete evidence review: label creation, a missing delivery estimate and a replacement still awaiting approval.
A disposable booking-and-attachment rehearsal exposes two failures that a successful database query cannot detect.
A time-only reporting example compares two improvements, their upkeep and the frequency at which either earns its setup effort.
Two explicit control paths separate difficult interpretation inside a known process from investigation whose next action depends on new evidence.
An invented three-policy corpus shows why applicability must constrain retrieval before attractive passages displace eligible evidence.
Omitted, empty and null fields express different edits. A contact example adds the version check that prevents an old form from silently overwriting newer work.
A source-checked illustrative transcript separates the original protocol’s common lifecycle and tool calls from source-specific meaning.
An order-to-operation crosswalk shows how useful correlation survives a new attempt, a new trace and a missing context field.
Three booking requests expose why intake, automatic writes and manual handling need distinct fallback decisions.
A source-read/report-write example shows why business purposes, OAuth scope and revocation boundaries need separate records.
An executed two-command example shows how a familiar test job can turn green by selecting less evidence rather than fixing a defect.
A small invoice-draft gate shows how tool and argument policy can reject unwanted effects independently of a model’s wording.
Four London clock examples turn a vague daily schedule into an explicit policy for ordinary, repeated and missing local times.
A worked 2,500-millisecond lookup shows why retries, backoff and response preparation must spend the same allowance.
A service-card specimen exposes the choice between preserving a tidy rectangle and preserving the words and link inside it.
A twelve-message routing sheet shows why labels, adjudication and case grouping come before a persuasive accuracy score.
A five-row price file reveals the gap between parsing text and agreeing what changes it authorises.
A fixed-slot booking example shows why a database invariant must cover competing writes, cancellation and a failed move.
Durable receipt, a membership transition and a welcome pack are separate obligations. Give each the identity and recovery boundary it needs.
A missing availability date may mean silence, a relative statement or a conflict. Preserve the difference when it changes the next action.
A read-only search slice can reveal whether a replacement preserves permission boundaries before the whole business depends on it. Six worked queries separate a useful ranking change from an unauthorised result.
A duplicate delivery, a repeated attachment and a corrected invoice are different events. A worked case model shows how one reviewer can keep them connected without confusing delivery with resolution.
The August 2024 announcement made output shape more dependable. A worked repairs enquiry shows why structure, evidence and diary availability still need different checks.
A retry key is a promise about a particular purchase. A worked request ledger and tested failure cases show what has to remain true when calls overlap, answers disappear and the payload changes.
No articles match those filters. Try another topic or a shorter search.
If a workflow, a system, or a stubborn bit of software is getting in the way, let’s talk it through.
