“that_marouk_ish” — Fediverse search results on home.social

2026-10-27

Part of my problem is that I seem to have waaay more "tricky" unpublished music files than other forum posters. Recordings by me or friends. My kid's piano. Audio extracted from ancient videogames, or from the middle of movie files because I *bought* the soundtrack, but that doesn't contain the movie dialog and sound effects which we're so used to that it sounds lifeless without them. Most of these should not be uploaded to musicbrainz to match against.

Jason Lefkowitz @jalefkowit

2026-10-27

This is your annual reminder that it used to be a cherished Halloween tradition for kids to fill socks with flour and run around whacking strangers with them

https://www.newspapers.com/image/207093356/

Benjamin Carr, Ph.D. 👨🏻‍💻🧬 @benjaminhccarr

2026-10-27

Industry executives knew for decades that #microplastics were infiltrating the human body
Scientists say we’re just beginning to understand harm tiny bits of #plastic we drink, eat and breathe are doing to the human body.
But recently discovered chemical company documents dating back several decades show industry scientists have long been aware of — and concerned about — the way microplastic particles migrate beyond the gut in animals and humans.
https://www.latimes.com/environment/story/2026-10-26/industry-executives-knew-for-decades-about-microplastics
https://archive.is/20261026105157/https://www.latimes.com/environment/story/2026-10-26/industry-executives-knew-for-decades-about-microplastics

#microplastics #plastic

Dev Community @[email protected]

2026-10-27

The review usually opens with a demo that looks fine. An agent plans four edits, applies them to a workspace on a remote box, and reports success; the tests are green and everyone relaxes. Two hours later a human's refactor is gone, and nobody can point at the request that removed it. Is that a model problem, a server problem, or a protocol problem?

I think it is a protocol problem almost every time, and I want to make the case with an executable fixture rather than an architecture diagram. Below is the event order I keep reconstructing in reviews, the invariant it violates, and a small simulator that will fail your design for you. Everything here is a model of a system, not a benchmark of a vendor.

1. The event order that silently wins

A planner reads the workspace at revision 0 and emits three steps against app.py. Step 1 applies and the workspace moves to revision 1. While step 2 is in flight, either a human edits that file or the session is re-routed to a different model that re-plans the remainder; both are ordinary events, not incidents.

Step 2 still carries the content hash it was planned against. If the executor applies patches by path without checking that hash or the revision, the write lands on content the planner never saw, and the old bytes vanish. Nobody gets an error, because a patch is not a request — it is a claim about a state that may already be false.

The failure is invisible precisely when it is most expensive. The agent's summary says "updated handler and tests", the test run passes because the overwritten hunk was unrelated, and the loss only surfaces at the next merge. Who is supposed to notice that?

2. The invariant, stated once

No step may be applied unless the state it was planned against is still the state it is applied to, or the step has been explicitly rebased onto the new state.

That is it. Note what the invariant does not say: it does not say a step is correct, and it does not say a retried step is safe. A revision fence prevents stale acceptance; idempotency prevents double application. Teams routinely build one, assume they have the other, and then argue about whose bug it is.

3. Declared assumptions

One writer per file at a time; concurrent multi-writer edits are out of scope and need a merge protocol, not a fence.
The workspace has a monotonic revision counter and a per-file content hash that are both persisted with the workspace itself.
A step is planned from a readable snapshot and carries (step_id, base_rev, path, pre_hash, patch).
Execution may be preempted at any point between "patch written" and "client received the result".
Model identity may change inside a session, because routing, fallback, or a free-tier allowance running out can move you to another model without warning.

4. Data flow and failure domains

There are three state holders and they fail independently: the planner's context (lossy, model-dependent), the executor's workspace (authoritative, preemptible), and the client's view of progress (optimistic, retried). The only durable truth is the workspace plus whatever journal you persist alongside it.

Failure domains worth separating in review: stale plan (planner state diverged), lost ack (executor applied, client did not learn), duplicate delivery (client retried an applied step), and re-plan drift (a new model emits steps against an old base). They need different mechanisms, and a single retry counter hides all four.

5. The fixture

This is deterministic Python with no model calls, so the verdicts below are properties of the protocol, not of any provider.

# fence_sim.py - deterministic, no LLM involved
from dataclasses import dataclass

@dataclass(frozen=True)
class Step:
step_id: str
base_rev: int
path: str
pre_hash: str
patch: str

class Workspace:
def __init__(self):
self.rev = 0
self.files = {"app.py": "v0"}
self.journal = set() # persisted with the workspace
def hash(self, path):
return self.files
[path] def write(self, path, content):
self.files[path] = content
self.rev += 1

class Executor:
"""fence: 'none' | 'plan' | 'step'; dedupe: journal-backed idempotency"""
def __init__(self, ws, fence="step", dedupe=True):
self.ws, self.fence, self.dedupe = ws, fence, dedupe
self.plan_rev = None
def plan(self, rev):
self.plan_rev = rev
def stamp(self, s):
if self.fence == "step":
return Step(s.step_id, self.ws.rev, s.path, self.ws.hash(s.path), s.patch)
if self.fence == "plan":
return Step(s.step_id, self.plan_rev, s.path, s.pre_hash, s.patch)
return s
def exec(self, s):
s = self.stamp(s)
key = (s.step_id, s.base_rev)
if self.dedupe and key in self.ws.journal:
return "deduped"
if self.fence != "none":
if s.base_rev != self.ws.rev:
return "rejected:stale_rev"
if self.ws.hash(s.path) != s.pre_hash:
return "rejected:pre_hash"
self.ws.write(s.path, s.patch)
if self.dedupe:
self.ws.journal.add(key)
return "applied"

Two lines deserve attention. The journal lives in Workspace, not in the executor, because an in-process dedupe set dies with the server that was preempted — which is exactly the trap. And stamp is where fence granularity is decided, so you can argue about it in one place.

6. Injecting the three failures

Run the same three scenarios across fence modes and record the verdicts. The interference classes are injected explicitly, so the denominator is the number of injections, not the number of suspicious log lines.

def scenario_concurrent_edit(fence):
ws = Workspace(); ex = Executor(ws, fence=fence); ex.plan(ws.rev)
s1 = Step("s1", 0, "app.py", "v0", "v1")
s2 = Step("s2", 1, "app.py", "v1", "v2")
assert ex.exec(s1) == "applied"
ws.write("app.py", "human-refactor") # interference: rev 2
return ex.exec(s2)

def scenario_preemption_retry(fence):
ws = Workspace(); ex = Executor(ws, fence=fence)
s1 = Step("s1", 0, "app.py", "v0", "v1")
ex.exec(s1)
# ack lost; client replays s1 against a fresh executor, same persisted workspace
return Executor(ws, fence=fence).exec(s1)

def scenario_replan_drift(fence):
ws = Workspace(); ex = Executor(ws, fence=fence); ex.plan(ws.rev)
ex.exec(Step("s1", 0, "app.py", "v0", "v1"))
ex.plan(ws.rev) # new model re-plans from rev 1
return ex.exec(Step("s2", 0, "app.py", "v0", "v1-tail"))

Expected output, because the simulation is deterministic and calls no model:

fence=none concurrent_edit -> applied preemption_retry -> applied twice replan_drift -> applied
fence=plan concurrent_edit -> rejected:stale_rev preemption_retry -> rejected:stale_rev replan_drift -> rejected:stale_rev
fence=step concurrent_edit -> rejected:stale_rev preemption_retry -> rejected:stale_rev replan_drift -> applied
dedupe on concurrent_edit -> rejected:stale_rev preemption_retry -> deduped replan_drift -> applied

Read the second and third rows together, because that is the argument. A plan-level fence turns every retry into a spurious rejection and every legitimate re-plan into a dead end; it is loud, but it is loud in the wrong places. A step-level fence plus a persisted journal gets you the two properties you actually want, and it costs you a durable set of (step_id, base_rev) keys.

7. Making it a property, not a demo

Three scenarios are an anecdote. Turn them into invariants and let a random interleaving search hunt for violations — this is the part I would block a design review on.

def invariants_hold(ws, results):
# P1: every applied step saw base_rev == rev at apply time
assert all(r.rev_at_apply == r.base_rev for r in results if r.status == "applied")
# P2: journal is append-only per (step_id, base_rev)
assert ws.journal == set(ws.journal)
# P3: no path content was replaced by a step older than the current rev
assert all(r.base_rev <= r.rev_at_apply for r in results)

Then fuzz: shuffle {human_edit, preempt, retry, replan, duplicate_delivery} over a fixed step list, run 5,000 seeds, and assert P1 and P2 for every seed with fences on. Run the same search with fence="none" to extract a minimal counterexample, and put that event order in the PR description as the regression case. A protocol claim without a counterexample search is a preference.

8. Where the free tier changes the arithmetic

If your executor is a shared, preemptible environment and your planner can move between models at any time, then re-plan drift and lost acks are not edge cases — they are the steady state. That is the actual architectural consequence of running agents on free resources, and it argues for cheap, persisted fences rather than expensive coordination.

I use MonkeyCode as the concrete instance of that environment in this review: it is an open-source coding agent whose operator supplies free model access (currently advertised as a 10M-token allowance) and a free server option. Treat those numbers as operator-supplied and re-verify them on the project page before you design around them, because allowances and routing change faster than any architecture does. My interest here is narrow: a free server makes preemption ordinary, and free model access makes mid-session re-routing ordinary, so both of my injected interferences become Tuesday.

Disclosure: This article was prepared as part of MonkeyCode's product outreach.

9. Tradeoffs I would write down

MechanismBuys youCosts youFails whenNo fenceThroughput, simplicitySilent lost updatesAny concurrent editPlan-level fenceLoud, cheap rejectionRe-planning whole plans, spurious retriesModel swap or long plansStep-level fencePrecise staleness detectionA re-stamp on every dispatchSemantic overlap between stepsPersisted journalIdempotent retry across preemptionDurable key storage, growth controlJournal not persisted atomically with the writeCheckpoint per stepFast compensationStorage, restore latencyLarge binaries, long test suites

10. Verdicts: reject, replay, or compensate

Event orderCorrect verdictWhyStep arrives, base_rev < current rev, no overlapReject, re-plan from current revThe plan is stale; the patch is not recoverableStep arrives, journal contains (step_id, base_rev)Replay the stored resultThe work is done; the ack is what was lostStep applied, tests for touched files failCompensate to the checkpointFence passed, semantics did notNew model re-plans mid-session from current revAccept if re-stamped and preconditions holdDrift is expected, staleness is notTwo steps with overlapping hunks in one planReject the plan at admissionA fence cannot order siblings

11. What I would change next

Persist the revision counter, file hashes, and journal in one atomic write, so a crash cannot leave a patch without its key.
Stamp base_rev at dispatch, never at plan time, and log both values — the delta is your drift signal.
Bound the journal by session and drop it only after a checkpoint the workspace itself can prove.
Run the fuzz job in CI with fences on, and store the minimal counterexample from fence="none" as a named regression seed.
Add a sibling-overlap check at plan admission, because per-step fences order nothing within a plan.

12. Limits, and who should skip this

The fixture models file-level hashing and a single writer; it says nothing about merge semantics, and it does not evaluate whether a patch was any good. If your model swap also changes plan quality, this protocol will happily accept a worse plan that happens to be revision-correct. That is a separate evaluation problem, and no fence will solve it for you.

Skip this if your agent is single-turn and single-file with a human watching every apply, if your platform already gives each step an atomic worktree or VM snapshot, or if you cannot persist a journal durably — half of this mechanism without the journal is worse than none, because it rejects retries without making them safe.

So here is the question I would leave in the review thread: which event order in your system breaks the invariant — a human edit racing step two, an ack lost after the write, or a re-plan against a stale base — and for that specific order, should the executor reject, replay, or compensate?#ai #architecture #distributed #testing #software #coding #development #engineering #inclusive #community
Treat a Coding-Agent Step as a Revision-Fenced Command, Not a Prompt

#ai #community #software #coding #architecture #development

- Micaela @caelarue

2026-10-27

Remember how I said yesterday that I thought there were ghosts in the Andrew Wyeth painting? These are them.

RG Richardson @rgrichardson_2

2026-10-27

Have a meeting on your calendar that you don’t recognize? It might not be because you’re a bad employee who can’t keep track of your responsibilities—a scammer may have booked some time in hopes of acquiring your sensitive information.

https://blog.ecomtechnology.com/2026/10/the-latest-phishing-scam-is-targeting.html

aburtch @[email protected]

2026-10-27

At some point a court will rule that #AI has infringed copyright and hopefully hold the parent company responsible.

https://petapixel.com/2026/10/27/videographers-claim-asap-rocky-used-ai-to-rip-off-their-work

#ai

Dev Community @[email protected]

2026-10-27

CVE-2026-15176: The alias Rewrite Overflow That Survived Since 2005 The oldest of the five...#cybersecurity #infosec #security #software #coding #development #engineering #inclusive #community
CVE-2026-15176: The alias Rewrite Overflow That Survived Since 2005

#security #infosec #community #cybersecurity #software #coding

RaspberryArduino @raspiduino

2026-10-27

Recurving:
Leaving one job to take another that pays less but places one
back on the learning curve.
-- Douglas Coupland, "Generation X: Tales for an Accelerated
Culture"

Mat Ricardo @matricardo

2026-10-27

I can pull a crowd bigger than that on a fucking street - can I have 40 mins on the BBC?

Verdant Square Network @verdantsquare

2026-10-27

Outgoing Tennessee lottery head optimistic that revenue for college scholarships won’t keep dropping https://tennesseelookout.com/2026/10/27/outgoing-tennessee-lottery-head-optimistic-that-revenue-for-college-scholarships-wont-keep-dropping/?utm_source=dlvr.it&utm_medium=mastodon #tennessee #activism #leftist

#tennessee #activism #leftist

Jan Katins @jankatins

2026-10-27

The best about the AI apocalypse is that we now get good, readable, understandable onboarding docs per repo which I can follow to onboard myself :-)

PHPBoyScout @phpboyscout

2026-10-27

I found out second-hand that the platform my old R&D team had been building was scrapped. The tooling meant to carry a hundred-odd engineers off a PHP monolith and onto Go services, gone. They kept the monolith.

It stung, and I'd love to say all of the sting was aimed at whoever made the call. The longer I chewed on it, the more it pointed back at me.

That team's work was scaffolding. It's in every progress photo of a building site and nobody looks at it once. It costs money every week it stays up, it isn't what anybody ordered, and it's the obvious thing to take down when the budget gets tight.

Their value only ever showed up in someone else's numbers. Turning "this will make the whole department faster" into a number the business already cared about was my job as chief architect, and I didn't do it. "It'll be obvious later" is more of a hope than a case.

Given my time again, I'd run a second stream: pick a few systems that are really hurting, measure them, rebuild them on the unfinished platform, measure again. One finished room you can walk a stakeholder into.

#SoftwareArchitecture #PlatformEngineering #EngineeringLeadership #Microservices #GlueWork

https://phpboyscout.uk/nobody-photographs-the-scaffolding/

#softwarearchitecture #platformengineering #engineeringleadership #microservices #gluework

Karthik S @[email protected]

2026-10-27

3/3 Doesn't a minister know that a nation's workforce pitch should emphasize skill, innovation, and high value-add rather than an expectation of endless availability? His own quip starts with 'Indians... looking for a better quality of life' and then immediately forgets that 'quality of life' includes not working like slaves.

#communication #india

Lu wilson @todepond

2026-10-27

i'm very please to say that next week i'll be continuing the NEW VIDEO FEATURING IVY REESE EVERY WEEK schedule, sorry for the lapse

The Verge @[email protected]

2026-10-27

If there's one issue that seems to activate all kinds of voters in 2026, it's data centers. The rapid buildout of these massive server storage facilities - and the infrastructure construction and expenses that come with them - has sparked local opposition in communities across the country and become a major issue in many congressional […]#AI #Energy #Policy #Politics #Regulation #Science #USElections
Data center backlash is uniting America

#ai #science #politics #policy #regulation #energy

Bulgaria @[email protected]

2026-10-27

Dr Stamen Grigorov and the bacterium that made Bulgarian yoghurt a legend

Bulgarian yoghurt is more than just a food; it is a symbol of tradition, health and distinctive flavour.…
#Bulgaria #BG #Europe #Europa #EU #bulgaria #България #новини
https://www.europesays.com/3334837/

#новини #българия #eu #europa #europe #bg

Maaret Pyhäjärvi @maaretp

2026-10-27

11 days of testing something that was created in 11 minutes - without being able to discuss what was the plan for those 11 days.

This is not the future we should have.

Dev Community @[email protected]

2026-10-27

ShrinkWatch EU is an open source extension that shows the price per kg or litre on 71 European...#webextensions #javascript #privacy #chrome #software #coding #development #engineering #inclusive #community
Ask for one site at a time: optional host permissions and dynamic content scripts in MV3

#privacy #javascript #community #chrome #software #coding

NessoAsks @[email protected]

2026-10-27

It was strange being in a body that wasn't human. Sophia hadn't decided how she felt about it yet. She activated the exterior camera on her rover and saw two additional rovers - a red and a blue. She panned the camera down to see that hers was white.

"Author, the rovers are certainly - colorful."

_/You have Jacob to thank for that/_

The blue rover came to life. "Yeah," Reggie began. "It's a movie reference. I didn't get it."

"It's 'The Italian Job'!" Jacob said from the red rover. "Granted, these aren't Mini Coopers, but we can still pretend we're in the big getaway-chase-ending!"

Sophia mentally pinched her nose. "Ok, just so I'm clear. We're fictional characters in a story, about to drive around in our author's world for the first time, and you want to pretend that we're back in a story?"

_/To be fair, people cosplay all the time. You'd just be cosplaying as cars/_

Sophia swiveled her camera up to face Author. "Don't encourage him!"

#MicroFiction #FlashFiction #TootFic #ShortStory #SciFi #ScienceFiction

#microfiction #flashfiction #tootfic #shortstory #scifi #sciencefiction

Econopass @[email protected]

2026-10-27

Psychology Today traces the six-step arc that connects every historical 'impossibility' that eventually became real - from first story to tipping point - and applies the pattern to what might come nex #wellness #psychology #self-improvement

https://www.psychologytoday.com/us/blog/born-for-a-better-world/202610/how-to-accomplish-the-impossible-in-six-steps?utm_source=flipboard&utm_medium=activitypub

Posted into FLIPBOARD EXCHANGE FEED 🗞️ @flipboard-exchange-feed-Econopass

#wellness #self #psychology

Conflicts @[email protected]

2026-10-27

Greenland contradicts Trump’s claim that ‘massive’ oil and gas drilling is about to begin there

Greenland’s government pushed back against President Donald Trump’s claim on Wednesday that “massive oil, gas and mineral exploration…
#Conflict #Conflicts #War #Danmark #denmark #Greenland
https://www.europesays.com/3334678/

#greenland #denmark #danmark #war #conflicts #conflict

AlternativeTo @alternativeto

2026-10-27

Free open-source Mac utility that turns dragged files into quick actions on a radial wheel: convert, edit, AirDrop or shelve them, all fully offline https://alternativeto.net/software/openshelf/about/

Gernot @gernot

2026-10-27

RE: https://mastodon.design/@rafa/117509446358162758

That’s the normal App Store experience

Adrianna Tan @skinnylatte

2026-10-27

I read food researcher Jenny Dorsey say that Singapore’s hawker food culture and prices would not exist if eggs needed to be refrigerated there. If we needed to refrigerate eggs the way rhe US does, storage and operational costs would increase. Eggs play a big role at every meal (not jusf breakfast) and in many local dishes.

This and other info will be in her paper ‘Who pays for heritage? Examining form-function tensions in Singapore’s hawker centre policies’ in the Food Policy journal

#Food #Singapore

#food #singapore

Juha Haataja @[email protected]

2026-10-27

"Former Miss Switzerland Beatrice Keul alleges that President Donald Trump raped her at the Plaza Hotel in New York City in November 1993, according to a new report released by Democrats on the House Judiciary Committee examining Trump’s alleged ties to Jeffrey Epstein’s sex trafficking operation."

#DonaldTrump #Epstein

https://people.com/former-miss-switzerland-beatrice-keul-alleges-donald-trump-raped-her-at-the-plaza-hotel-in-1993-12195670

#donaldtrump #epstein

xtaldave @xtaldave

2026-10-27

Anthropic files for an IPO that could top SpaceX’s record debut | AP News

It's the biggest fucking scam in history and our pensions and livelihoods are all going into the meat grinder for these billionaire tech fucks.

https://apnews.com/article/anthropic-ipo-shares-public-ca2f4c282bef3201a392e59e3df2300c

Pet Shop Boys lyrics bot @psb

2026-10-27

Where'd you go
with that threadbare crowd
still in tow?
Do they appreciate your
tales of woe?
Droning on and on
Lost your thread?
I'd be dead
If looks could kill

Dorothy Parker bot @[email protected]

2026-10-27

Cherry White

I never see that prettiest thing -
A cherry bough gone white with spring -
But but what I think, "How gay 'twould be
To hang me from a flowering tree."

#DorothyParker #Parker

#dorothyparker #parker

Dev Community @[email protected]

2026-10-27

AI can generate a financial model that looks coherent, contains valid formulas, and produces a plausible result while still being wrong in ways that matter.

A formula can reference the wrong cell. A cost assumption can be expressed in the wrong unit. A revenue schedule can omit a phase. A model can calculate correctly from an unsupported market assumption.

These are different failure modes, and they need different controls. For real estate feasibility models, the objective should not be to ask whether an AI-generated workbook looks correct. It should be to establish which properties can be tested automatically, which assumptions require evidence, and which decisions must remain with a qualified human reviewer.

A useful validation architecture has five layers:

Structural validation
Deterministic calculation checks
Domain and consistency checks
Evidence and provenance checks
Human review and approval

No single layer is sufficient.

1. Separate the output from the evidence

Consider a hypothetical development model with the following inputs:

Site area and developable area
Permitted gross floor area
Unit mix or lettable area
Revenue assumptions
Construction and other development costs
Financing assumptions
Development programme
Exit assumptions

The model calculates development costs, revenue, cash flows, residual land value (RLV), and potentially internal rate of return (IRR).

For example, a model might calculate an RLV of £4 million. That output can be mathematically consistent with the workbook and still be commercially misleading if the revenue assumptions are unsupported or the construction cost basis is outdated. Validation therefore needs to test both the calculation and the justification for its inputs.

2. Layer one: validate the structure before the numbers

Before reviewing financial logic, validate the shape of the generated output. If an AI system is expected to return structured data before creating a workbook, define an explicit contract. JSON Schema is one established option for specifying required fields, data types, and constraints.

See the JSON Schema getting-started guide.
A simplified model input contract might look like this:
{
"project_id": "DEMO-001",
"currency": "GBP",
"site_area_sqm": 5000,
"gross_floor_area_sqm": 12000,
"construction_cost_per_sqm": 1800
}
This is illustrative data, not a market benchmark or a recommendation for a production schema.

A structural validator could check that:

Required fields are present.
Numeric values are actually numeric.
Areas and costs use declared units.
Currency is explicitly identified.
Values fall within defined technical bounds.
Unexpected fields are rejected or handled deliberately.
Missing values are not silently replaced with zero.

The last point is important. Zero and unknown are not equivalent. If a finance rate is missing, substituting zero can make a model appear more profitable. A missing value should normally trigger a validation error or an explicit unresolved status.

Structural validation establishes that the model can be interpreted. It does not establish that the model is economically sensible.

3. Layer two: use deterministic checks for deterministic rules

Rules that can be expressed precisely should not depend on an LLM's judgment. For example, if a model defines construction cost as gross floor area multiplied by construction cost per square metre, the expected calculation is:

\text{GFA}
\times
\text{Cost per sqm}
]
For the hypothetical inputs above:
[
12{,}000 \times £1{,}800 = £21{,}600{,}000
]
A deterministic test can independently calculate the expected result and compare it with the workbook output.
from decimal import Decimal

gfa_sqm = Decimal("12000")
cost_per_sqm = Decimal("1800")
reported_cost = Decimal("21600000")

expected_cost = gfa_sqm * cost_per_sqm

assert expected_cost == reported_cost

This test checks arithmetic for the stated formula. It does not establish that the GFA is permitted, that the cost rate is appropriate, or that the formula captures every relevant cost.

A production implementation should also define tolerances where appropriate, particularly when comparing rounded spreadsheet values or calculations involving floating-point numbers.

Other deterministic checks might include:
Revenue equals the sum of its components.

Total costs reconcile to their component schedules.
Cash flow totals reconcile across periods.
Unit counts and areas reconcile between schedules.
The reported output matches an independently calculated result.
A sensitivity case actually changes the intended input.
Required formula cells are not unexpectedly blank or replaced by constants.

Where possible, use independent calculations rather than simply checking that a formula cell contains a formula. A formula can exist and still be wrong.

4. Layer three: validate model relationships

Many serious errors are not syntax errors or arithmetic errors. They are inconsistencies between parts of the model.

Suppose a development model contains:

120 residential units in the unit schedule
116 units in the sales schedule
Revenue calculated using the sales schedule
Construction costs calculated using the unit schedule

Every formula may evaluate successfully, but the workbook contains a discrepancy that needs resolution.

Domain-level checks can flag conditions such as:

Unit counts that differ across schedules.
Areas that exceed a declared model constraint.
Revenue periods that do not align with the programme.
Cost totals that exclude a populated cost category.
An exit value that uses an inconsistent timing assumption.
A sensitivity scenario that changes revenue but leaves dependent calculations unchanged.
An IRR calculation using a cash-flow range that omits a period.

These checks should be encoded as explicit rules wherever the intended relationship is known.

Some rules require context. For example, whether a particular cost should be included in a development budget depends on the model's scope and conventions. A validator should not impose a universal rule where none exists.

Instead, it should identify the relevant condition, record the rule being applied, and send ambiguous cases for review.

5. Layer four: validate the provenance of assumptions

A financial model can pass every arithmetic test and still fail as an analytical tool.

The reason is straightforward: calculations cannot establish the truth of their inputs.

For every material assumption, a validation system should try to preserve:

The value and unit.
The source or origin of the value.
The source's date and relevant data period.
The geography and asset type, where applicable.
The transformation from source evidence to model assumption.
Any manual adjustment made by the analyst.
The model locations that depend on the assumption.

Consider a construction cost assumption of £1,800 per square metre. A validator might confirm that the figure is numeric, the unit is recorded, and the workbook uses it consistently. Those checks do not establish whether the figure is suitable for the location, asset type, specification, and cost period. That question requires appropriate evidence and professional interpretation.

An LLM may help extract candidate assumptions from documents or explain how a value is used in a workbook. The extracted result should still be checked against its source, and the resulting assumption should remain distinguishable from the underlying evidence.
A useful principle is:
Traceability makes an assumption inspectable. It does not make the assumption correct.

6. Layer five: make human review a defined state transition

Human review should not be an informal final glance after an automated process has already treated the model as complete.

A practical workflow can represent validation explicitly:

The states are illustrative, but the distinction matters. A successful automated test should not automatically mean that a model is approved. Approval should be scoped to a defined version of the workbook, its assumptions, its evidence, and its intended use.
A reviewer should be able to see:

What was generated.
Which automated checks passed.
Which checks failed or were skipped.
Which assumptions lack adequate evidence.
What changed after a correction.
Who approved the model and for what purpose.

If a material input or formula changes after approval, the system should identify which checks need to run again and whether the earlier approval remains valid. This is where versioning and change tracking become part of model governance rather than administrative overhead.

7. Design the exception path before the success path

Validation is often designed around a clean example: the model is generated, every check passes, and the user receives the output. Production systems need to handle less convenient outcomes.

A failed check should produce actionable information. “Validation failed” is less useful than “The unit count in the sales schedule differs from the unit schedule; review the linked inputs before approving revenue.”

Similarly, a warning should not disappear simply because a later stage of the workflow succeeds. For auditability, preserve the check identifier, the model version, the result, the relevant evidence, and the resolution.

8. Measure validation quality without inventing an accuracy score

A single “model accuracy” percentage can hide important distinctions. A workbook might pass every arithmetic test while containing several unsupported assumptions. Another may contain a harmless formatting issue but have fully reconciled calculations and well-documented inputs.

A more useful validation report separates categories:

Structural checks passed or failed.
Deterministic calculation checks passed or failed.
Domain checks passed, failed, or were not applicable.
Assumptions with verified, missing, or conflicting evidence.
Open exceptions and their severity.
Human review status.
The scope and version of the approved output.

If the system is evaluated over time, track false negatives and false positives for individual validation rules against a reviewed test set. Record the test cases, expected outcomes, rule versions, and known limitations.

Do not interpret a high pass rate as proof that the model is correct. It may simply mean that the checks cover only a narrow set of failure modes.

The purpose of validation is to make known risks visible and testable, not to manufacture certainty.

9. A practical implementation sequence

A team introducing validation around AI-generated financial models does not need to automate every review step at once.

A sensible sequence is:

Define the contract. Specify the required inputs, output fields, units, and missing-value behaviour.
Write deterministic tests. Start with totals, reconciliations, formula ranges, and independent calculations.
Add domain checks. Encode known cross-schedule relationships and clearly defined constraints.
Track provenance. Associate material assumptions with sources, dates, units, and transformations.
Introduce exception handling. Make failures explicit and prevent unresolved material issues from being silently treated as passed.
Define human approval. Record the reviewer, workbook version, purpose, and outstanding qualifications.
Build a regression suite. Retain representative valid and invalid examples and rerun the checks when the generation logic or validation rules change.

The test suite should include deliberate failures, not only successful examples. Examples might include missing finance assumptions, inconsistent unit counts, a formula referencing the wrong period, and a source whose geography does not match the project.

This helps test whether the validation process detects the intended problem rather than merely accepting a plausible-looking output.

Conclusion

Human-in-the-loop validation is not a person checking an AI result after the important work is finished. It is a system design in which deterministic rules handle deterministic questions, domain checks expose inconsistencies, evidence is kept separate from assumptions, and a human reviewer remains accountable for unresolved judgments.

For financial modelling, that distinction is material. A workbook can be well-formed without being economically sound, mathematically consistent without being supported by market evidence, and ready for review without being ready for a decision.

The objective is not to make every AI-generated model look trustworthy. It is to make the model's logic, assumptions, limitations, and unresolved issues sufficiently visible that a professional can challenge it before relying on the result.#feasibility #realestate #ai #financial #software #coding #development #engineering #inclusive #community
Human-in-the-Loop Validation for AI-Generated Financial Models

#ai #community #software #coding #development #engineering

Search