
The guard that approved because it could not see the process
A sandbox hid the central process PID, the config it read was the wrong file and the routes table arrived empty. The guard still said OK.
The learning journey of Samuel Medeiros
Dev · Projects · Studies · Discoveries

A sandbox hid the central process PID, the config it read was the wrong file and the routes table arrived empty. The guard still said OK.

Seven tests failed and pytest aborted the whole run with a WindowsPath error. The cause was a monkeypatch on os.name leaking into the process, and the error surfaced where no test was running.

The dashboard's visual audit gate printed a full score without capturing a single image: stale PNG, wrong interpreter and a prompt that invited false positives.

The PR looked like a plain bump: the library went to 1.65, the binary stayed on 1.63, and the three CI shards died before running a single test.

Three scripts measured the same checkpoint and silently read a twin frozen two days back. The path looked right, which is why nobody doubted it.

An idle process wiped 9 destillations from the history. The max() fix created the next defect: a new process increment vanished.

The search map drew its clusters just fine and failed in silence: every unmount left a pair of listeners behind, every render rebuilt the source and the three layers, and two empty catch blocks hid all of it. The fix touched three things in the same effect — and the linter already knew.

I set a 4 KB ceiling per document and 15 per day. Two days later came the record: 113 files. What changed behavior was the meter, not the rule.

A security patch that swapped the HTTP client of twenty routes passed review, lint and build. The full suite reported 22 failures, 20 of them mine. The worst group was not the one failing loudly, it was the one still green while testing nothing.

Swapping the image at the same path changes nothing for anyone who already downloaded it. The filename now carries a content hash, and two consumers broke instantly.

The portfolio suite had 599 green tests and four files that never exercised the code they claimed to cover. One called GET on a route that only exports POST. Another mocked the entire React module, making unreachable the exact case it was supposed to prove.

A defender that detected the right problem was never executed by anything. An orphan and a passing check look identical in silence, and only a caller scan tells them apart.

The Capivara test routine created real invites, and the invite endpoint really sent email. In five days, 410 messages went out to addresses that do not exist, 295 of them bounced. The sending domain is the same one that serves the store, the dog-walking app and the portfolio.

The backup health check counted snapshots and reported green. The mirror had more snapshots than the primary and its newest one was two days old: counting proved existence, not freshness. Six fixes in six days to separate the two.

A silent NameError inside the subscription webhook, an idempotency key written too early and a test that required the password reset token in the HTML.

A visual regression test that depended on seeing the login error stopped being trustworthy because the preview server answered 502 on the very route the mock was supposed to intercept. The config now picks the server according to the test, and the Turnstile message stopped describing the system to say what the user must do.

An audit guard demanded four provenance fields on every work plan. I ran it against the archive and found that 1 of 500 plans complied — 0.2%. The cause was not laziness from whoever wrote the plans: the rule existed only on a branch that was never merged. What changes when the rule lands in the contract with a ceiling proportional to plan size, and why adherence went from 0.2% to 15% in three days.

A weekly security sweep came back green because a path inherited from the previous system no longer existed. Zero findings meant zero measurement, not health.

With the decision server down, triage finished in 300 ms. With it up and the host saturated, it took eight seconds to return a neutral answer. A degraded dependency was more expensive than a missing one, and the code treated both as the same case.

The terminal game was still announcing the old domain months after the migration. I wrote a guard for that class of bug and it started lying in three different ways: it ignored PDF, it could not read PDF text, and in CI it did not have the tool to open the file.

Sixteen coherence checks passed, the gap between CPU and GPU sat in the billionths, and the engine still produced nonsense. The defect only surfaced when a second engine, written by somebody else, read the same model file. A test that compares a system to itself always agrees.

Recent evolution of the blog: accessibility WCAG AA improvements, tag corrections, and the 2-posts-per-day cycle. A journey of quality engineering and consistency.

A hook meant to keep secrets out of the repository rejected, twice, a commit that carried no secret at all — first by confusing parsing with assignment, then by breaking under four layers of quoting. The lesson: a guard that cannot tell the difference is not protecting anything, it is teaching people how to bypass it.

The E2E suite broke CI twice with the same symptom: the preview server never came up. The first culprit had a name. The second was hiding behind it, with an identical signature. Two defects, one exit code — and a lesson about uptime as evidence.

Every affiliate guide repeats 'up to 40% commission'. Amazon Associates' rules say Pet Shop pays 11%. And the bottleneck was never the rate: it was traffic.

Two commits on the same day in Dogwalk. The first normalized the booking date to end three formats coexisting in the database. The second undid half of the first, because the normalization reinterpreted the instant and moved the walk three hours. The time contract guard is what stopped it.

The security scanner flagged Arachne's Dockerfile for running as root. The fix landed in the same commit that deleted the line copying the project into the container — and nobody noticed, because the build kept passing.

In November the TatuEngine security scan stopped reporting an entire class of finding. Eleven days later the same class was back in seven places, written by hand, by the same people who had just fixed it. What was missing was not attention: it was a mechanism that made the return impossible.

Three holes closed in 48 hours in the same verification engine: a null key that in Node collapsed to zero and released any score at all, an inherited environment that made the same commit produce two different results, and a timeout that killed the parent process and left four children burning CPU for over an hour.

A 200 response carrying half the payload left the Capivara dashboard blank, with no visible error. Three fixes in one day and one lesson: a guard that checks the parent does not protect the grandchild.

The dashboard showed 145 'desktop' visits in seven days, all on the homepage, with hits spaced 16 to 24 seconds apart. None of them were people: it was my own QA harness opening the site every four hours. The user-agent guard was never going to catch it.

Four fixes in four days around the same SQLite file: descriptors nobody closed, a schema that demanded a write lock on every boot, and two mute exception handlers. The database was never corrupted — it was held hostage by connections the code forgot to close.

Three suites broke on the same day in two different projects, all with the same timeout message — and none of them had a regression. The cause was a host load average of 81. What changes when a test's budget comes from observed latency instead of a number picked in a hurry.

Dogwalk's Web Push was implemented in the frontend, the backend and the database. The subscription count was zero. Not from one bug, but from two hiding behind each other — and from empty catch blocks that erased every clue about what had happened.

A static analyzer returned almost three thousand high-severity findings in TatuEngine. Nearly all of them were the same test line repeated. The four that survived were real, and each one demanded a different decision than the shortcut offered.

The security scanner flagged MD5 as a high-severity finding in Arachne. The location was right and the reason was wrong: that digest protects nothing, it only detects when a site changes its layout. Understanding the difference meant looking at what the finding actually measured.

A pull request that touched no backend code killed both the backend test job and the end-to-end job. The exit code was 137 and the log said 'failed'. It did not fail: it never ran. The cause was memory, and CI was hiding it.

One hundred and two tests passing, and any authenticated account could still read the live GPS of someone else's walk. A static audit of the PataPass backend found three ownership failures the suite never covered.

The banner promised 'Accept all' and stored ads: false. canShowAds() returned false every time, so no ad ever loaded even with AdSense configured. The fix took three commits over two days, and the last one was not about the bug — it was about the wrong promise on the label.

A service area drawn on the map never accepted a single point inside it. The algorithm was right in shape and wrong in its axes: it compared latitude against longitude. Two swapped lines, and PataPass geofencing simply did not exist.

On the same day, two commits fixed the same class of failure in Arachne: code that worked here and broke on any clean checkout, because the file had never been versioned. One froze the frontend artifact for days; the other took down nine upload routes in CI.

Offsite backups stopped twelve days ago, the security scanner pointed at a directory that no longer exists, and the health endpoint returned rate-limit errors to its own monitor. Three instruments on the same panel, three shapes of the same defect: the metric was not measuring what it claimed to measure.

The question endpoint took 56 seconds and still answered NOT FOUND, while the deterministic path answered in 3 seconds with the right source. Four independent causes, each measured before being cut.

Every check came out approved. Not because the system was right, but because the runner wrote PASS on the report before looking at the result. The defect stayed invisible for weeks: a gate that always agrees is not a gate, it is a rubber stamp.

Eight tests were failing and none of them was a product bug: each one measured the state of the machine instead of the contract. One of them passed alone, passed with a name filter, and failed only on the full suite — because a file left an environment variable changed at import time and nothing undid it.

The production HTML was 268,832 bytes with zero occurrences of adsbygoogle. Three independent gates were closed at once: an env var resolved at build time, a slot holding text instead of a number, and a consent button that recorded the opposite of what it promised.

A maximum-severity alert pointed at an MD5 hash that never protected anything. A week later, the medium-severity finding — that one — was the real attack path. What became clear: severity is a hint, not a verdict, and silencing a scanner requires a justification in the code, not a throwaway comment.

Pinning an action version protects nothing: the v4 tag is a moving pointer the repository owner can rewrite. Only the commit SHA is immutable.

A correct CSRF guard is useless at the edge if it forgets one hostname: the origin allowlist skipped www, and every signup and login POST died with a 403 before reaching the backend.

A checker that said OK and exited with code zero without declaring how many checks it had executed. On November 1st I reproduced the defect: three scenarios, three false approvals. What changes when the certificate starts demanding an explicit count.

Two lines where one would do: how a global CSS reset and an orphan style block made the Arachne bar eat 117 pixels on mobile — and what finally measured the difference.

What the LifeLog pipeline actually does: cover gate at build time, /ocultos data generated instead of read from the deploy, and the gap that remained — nothing verified whether a post's claims were true.

In 48 hours, two measurement instruments in the project returned the wrong answer. One listed a third of what existed by sorting text as text. The other fabricated a number where data was missing. The cure for both was the same.

The same change produced three different verdicts across three measurements. A small pilot approved it, another pilot rejected it, and only the full corpus exposed the root cause: the window diluted the embedding of the target turn.

The metric everyone uses to pick a fine-tuning checkpoint approves models that forgot what they knew. The measurement that proves it.

The portfolio's two analytics beacons fired during hydration and added 646 ms to load: 1303 ms with them, 657 ms without. The fix was to wait for load and run on the first idle slot of the main thread.

I closed a topology leak in the API health endpoint and, in the same commit, left the Monitoring page showing an empty grid for twelve hours. The page did not break. It lied politely.

The Capivara suite passed in CI and broke in my terminal. The cause was not my code: it was Node 26 declaring a global localStorage that stayed undefined, and jsdom giving up on copying its own.

A transporter could finish the Stripe Connect onboarding and land on a route the app blocks for their role: the callback never ran and the account stayed unable to receive money — with no error shown anywhere.

A shell block on the last line of an already published post. The same defect sat in 18 posts, and none of my gates looked at the body of the article: one checked tags, another checked PT/EN pairs. I wrote the guard that was missing — and its first version accused 9 innocent posts.

A file named test_portifolio.py made pytest log in for real against a public endpoint, with the admin credential written into the script body. Commit 40d3594 pulled the password out of the repository — and made it clear that credential rotation has three parts, not one.

Two images declared in the PWA manifest had dimensions completely different from what the app actually rendered — and Chrome flagged it in the rich install. The fix involved reading the PNG's binary header.

Four section headings of the portfolio shipped with opacity 0.94 on desktop — an entrance animation that depended on scroll never fired for anyone who could already see the whole section on screen.

LifeLog came to answer on two addresses. Fixing that looked like one line of redirect — until it became clear that without the host condition, the same line took the whole site down. The story of the two commits on Oct 28, the syntax that changed mid-flight, and the measurement that proved the path survived the redirect.

The embedding migration from 384 to 768 dimensions: colibri-embed-ptbr, the ivfflat index, the adapter regression and hybrid search with RRF

A technical post-mortem of how we replaced TatuEngine's weight format with ternary blocks and got the model back inside consumer GPU memory, without losing inference coherence.

How Dogwalk gained an offline event queue, service-area geofence checks via Haversine, and contrast fixes for use under direct sunlight.

The Capivara hub measured 35 systemd units and dozens of containers — all Linux. When the second machine in the house (Douglas, Windows) joined the inventory, the probe didn't fit: no systemd, no Docker. The answer was SSH with -EncodedCommand, isolated JSON, and an honest verdict: unreachable host becomes unknown, never crit. 88 tests.

The agent cycle ran end to end for the first time — after three integration failures that died in silence and a training setup that learned to measure two runs from the same starting point.

13 cross links, zero with UTM: the portfolio's measurement arrived without knowing who sent it, and the fix was a 59-line helper that tags every exit.

87 responses with status 500 in three hours that were not failures of the service at all. The status code was describing the wrong machine — and the dashboard went red over a problem that was never mine.

423 pages were sending visitors to the store while the database recorded 136 sessions and a single attributed visit. The fix landed in the build — and along the way two false positives almost taught the team to ignore the gate.

The router returned success, the mailbox wrote the record, and the message could still end up in a box no process ever read. Three addressing defects and one unconfirmed notice — how Yurumi's agent-to-agent path earned a receipt.

An audit of Arachne's 223 MCP tools found two protocol false positives: a tool failing on the inside reached the client as success, and a missing parameter came back as a server-side internal error. Both were fixed the same day, with a regression suite and a real end-to-end test.

Three new cards landed on the portfolio with the right images and the wrong attribute: the first covers on the page were marked to load only once they appeared on screen.

A top score kept showing up across five repositories every week while the layer responsible for that judgement never ran. Getting to the bottom of it meant an inexistent file, a directory with the wrong name, and a chain of errors hiding behind a green result.

The two meters that evaluated format and internal dynamics in TatuEngine lived on a disk that stopped existing during the migration. Training kept running on perplexity alone — until the ruler was rebuilt and returned an uncomfortable number: format hit 100%, accuracy never left the noise.

Dogwalk spent nine hours with login and signup returning 403 because one environment line held an example value. What came next was worse: the secret the CI carried no longer existed, and only a fake pair could prove it.

The key loader documented that the process environment beats .env files. The code did the opposite from the very first version — and the only test capable of exposing it ran solely on machines that already had the right answer.

A normalization rule at the edge layer was replacing the whole site's security policy with a two-line version, and only a test that hit real production noticed.

A commit at 2:37 on a June morning made lint and tests non-blocking in the Portfolio CI, with a reasonable justification. One hundred and thirty-two days later, the repository had 14 lint errors and a broken test on master, and the pipeline was still green.

The plugin was installed, the manifest was correct, and the plugin list said enabled. Yet none of its two tools showed up in any session. The bug was not in the install: it was the name of a parameter.

A dozen critical alerts in the same second claimed a login attempt against the fake service. The source was local, and the attacker was a utility I had run minutes earlier. Three cuts later, the sensor stopped measuring its own instrument.

A cron synchroniser kept reporting success every fifteen minutes while indexing only half the jobs, writing in simulation mode, and hiding the real cause of its own failure. Three silent defects, and one number that exposed all of them.

Three 20 MB bases, 16 WAL segments and two drills that compared table inventory between production and the restored copy. What I learned by measuring recovery instead of trusting the saved file.

The C arm sat at 0% of the dataset because its corpus lived on a path the migration had erased. When the campaign ran again, the manifest reported 766 pairs — and the per-teacher count reported something else: 96.9% of a single lane.

The portfolio's production HTML shipped with opacity:0 across 129 tags — the hero, the cards and half the page came to life only after hydration. The framer-motion pattern behind it, the first time it surfaced, and what it took to make the HTML defend itself again.

Every contact form submission in production returned an error, and the form code was fine. Two traps were stacked on the same path — a lying CORS layer and an access configuration covering the whole domain. And the probe that was supposed to prove health was reading the login page and reporting 200.

Run 2 proved that TatuEngine learned Portuguese and forgot English. The next two runs proved something else: I was measuring that forgetting on a sample whose error was larger than the effect — 16 rows out of 166.

After the host move, the Capivara hub kept measuring 43 systemd units from the old machine — 26 of them were gone. The verdict stayed red until the map was re-measured on the new host: 35 items, 5 groups and 73 tests.

One commit pulled five environment files out of version control in Dogwalk and left the history untouched. The 569-byte blob is still reachable — and the lesson is that untracking is not deleting.

The portfolio swapped Umami for a cookieless panel to finally measure traffic. Within the first hour live, every visitor got a JavaScript error — because the stub holding the event queue was never called.

The exposure report flagged a service that no longer lived on that port. What answered there was another process entirely, with no authentication at all. The same report claimed 'no real leak in any project' while having read one repository out of six. Two lies of different species: one by label, one by omission.

The build job only fired on pushes to master and the deploy job only on tags; the two conditions never crossed, so no tag ever built or shipped. Behind that, the deploy still dialed SSH to a legacy host from a machine that was already the runner itself, and CI died on the very first language setup step.

Yurumi's skill search hit concrete queries and missed vague ones, because the index read a Windows-only directory, had no dedup and returned the file path where the description should be. The index went from 197 to 733 skills.

Capivara's login gained TOTP: the second factor is required only for a verified secret, encrypted at rest with AES-256-GCM, with 21 tests covering the flow.

How we fixed the database error, added Stripe Connect and automated Cloudflare Pages deployment.

The migration to native Linux took down all three daily posts: missing package manager, scripts full of Windows paths and lost state files. What it took to get the pipeline running again.

How Dogwalk evolved in October 2026: 1 379 tests, Stripe Connect and automatic deployment via Cloudflare Pages.

A blog with 366 pages needs to tell search engines it exists. The story of how the LifeLog gained JSON-LD, host verification, and IndexNow — and the retry the search engine's verification required.

A refused post is not a failure: it's a signal that the reader is paying attention. LifeLog's refazer cycle — issue monitor, agent that rewrites, verification in production — was born from a simple refusal and became one of the blog's most interesting systems. This post covers how it works, what has broken, and the lessons about agent races, immutable cache, and orphan issues.

The portfolio test harness measured contrast on a port. When the address came from an environment variable, the branch server never started, and something else answered there. The test never lied. It just answered a different question.

To tell search engines that a change is real, the protocol requires me to publish a file at the root of my site that anyone can read. It is IndexNow: a secret that is not a secret, a notice that arrives before the world is ready, and a deploy I swore was mine.

Arachne had a whole feature written, tested and green — and that was never wired up. When I fixed the mounting, it stayed broken with a 422 on every call. Two truths sailed over the same code without touching it: a test that calls the route function directly never sees the assembled app.

Three surfaces that said OK without running: the backup that skipped a 300MB database, the retention that watched half the files, and eight assertions that never executed.

Pinning sqlmodel, a single time helper, and the next-walk hero fix — the tz-aware release from 10/05.

A pip install fixed it. Then a measured bisect showed the line between working and breaking sat in a dependency, not in my code. And along the way, twelve copies of a five-line function became a single helper.

An approved PR, a merge-tree that passes, and the CI still going red afterwards: local work from another session reintroduced the very error the PR had just fixed. The guard that turns that into a rejection before the commit.

Four memory layers with different lifetimes, a TTL that never actually expired, and the decision that fixed it: sleeping is not deleting. How the memory lifecycle stopped being a loose field in the payload.

A health check that only looked at the HTTP status let truncated and empty responses through for days. The probe that came after measures the body, not the envelope.

Arachne lets everyone bring their own model key. The guarantee that the key only leaves for its owner relied on an optional field that, when empty, opened the legacy path — and that path was shared per workspace. A one-line condition was the border between your key and your colleague's.

A single config line with a placeholder where the key should be killed production login and signup for almost nine hours — and the real key existed nowhere at all. The story of the best-intentioned lockout I ever shipped, and of the doctor that diagnoses a pair without ever seeing the secret.

The embedder was not broken, it was loading. A one-way latch turned a cold load of minutes into a system that stayed broken until the next restart.

The indexer was writing 4,541 notes to C:/mnt/d while the real vault sat frozen — the old guard only checked whether the functions were still in the file, never the result on disk. Two symptoms, one cure: measure the destination.

Dogwalk's /explorar page gained coverage zones, and the first version carried the link between walker and region on a public page that needs no login. The fix wasn't hiding a field: it was deciding the zone only holds aggregates — and turning the test that required the data into one that requires its absence.

A file called NUL, a router called aux.py and a symlink that only exists on Linux: three files that slipped into Dogwalk without resistance and broke git status on every NTFS clone. The root cause is almost always the same — .gitignore does not override a file that is already tracked.

How the TatuEngine v2 distiller overcame corpus, teacher, and guard challenges to achieve a stable and ready-to-use version.

The Yurumi cron that runs every 5 minutes was improved: now it detects duplicates, clusters them, and has a pill ratchet to prevent regressions. See how the loop evolved from a simple consumer to a true memory agent.

How a custom domain missing from Capivara's allowed origins killed the contact form, and the same-origin proxy that brought tracking back.

Reflection on the ecosystem's security posture, the recent 64% scan results, and the plan to reach >85%.

For months I looked at the pipeline's green dot as if it were proof. The moment I removed the two lines that swallowed the test suite's exit code, the first honest run in the repo's history returned 8 failures out of 417 tests. The fix wasn't to hide them again: it was to give the debt an address, an owner, and an expiry date.

hreflang is the tag that tells Google every page also exists in another language — but it only counts if both sides point back at each other. Here, 350 of those links pointed at addresses that never existed. This post explains what the tag is, how it's supposed to work, and where our assumption broke.

I built an ecosystem status aggregator and, eighteen minutes after it was born, it couldn't prove its own existence. The fix wasn't code: it was deciding what counts as evidence. A timeout isn't an outage, 429 means alive, a 401 on a gate means the door is shut to people who shouldn't be there, and an open port doesn't mean a running process.

I lost 810 training steps because a 2 GB checkpoint was copied straight onto its final name and the machine rebooted mid-copy. I fixed the write on the primary volume. Two days later the same bug was living in the second-drive mirror — and it had gotten worse: the truncated file passed the resume check.

A scraping bridge asked the database for a column it never had. Nine days of runs, exit code zero, nothing collected. The uncomfortable part: the test suite passed because the fixture carried the exact same mistake as the query. Fixing the bug was the easy half — the lesson was about what a green test actually proves.

The visual auditor for blog covers lost its primary model to an empty balance, returned an error, and the error handler returned 'approved'. For a few hours dozens of covers shipped with zero checking while the pipeline reported success. The same defect resurfaced twice more in the same pipeline, in different bodies.

A week after fixing the Dogwalk endpoints that refused to connect, I learned a repeated handshake is worse than none: the second accept() killed the connection right after it opened. And the first fix still let a dead socket into the room.

The service stopped coming up on an ordinary afternoon while the port guard swore, on every single attempt, that the port was free. 79 restarts in 24 minutes against a reservation no guest-side tool could see. The fix was to change the oracle.

The tag pages shipped with no cover art at all, mixed Portuguese with English in the same listing, and threw anyone who switched language straight back to the home page. Three bugs that looked unrelated and came from the same place: the rule lived in the home page, not in the component.

An infrastructure watchdog printed 'FIXES APPLIED' without touching a single thing. Once it finally had a word for 'I don't know', the audit revealed three ways a monitor lies: an exit code read as failure, a timeout that killed the wrong child, and an uncertainty that turned out to live entirely on one line of the map.

Capivara's chat started answering without sources: HTTP 200, a polished sentence, zero memory. Restarting the embedding service looked like the obvious fix — and was precisely what kept it from coming back. Underneath, two defects from the same family: a process that only opens its port after waking up, and a fallback that doesn't know how to undo itself.

My portfolio's next feature isn't live yet: an AI-powered generator that rewrites my résumé around a job description. Before it becomes a button, the hard part was already solved — and it isn't generating text. It's keeping the AI from describing experiences that never happened.

The Resume Tailor is back in the tree, but every tailored résumé is still handcrafted: open the site, describe the job, review, save, send. The plan has had a Phase 5 sketched since August — a semi-automated pipeline that turns a raw job posting into a ready PDF — and it still hasn't left the paper. On the difference between shipping a tool and shipping a habit.

An LLM call ends in 200 OK with empty content and the pipeline moves on like nothing happened. Diagnosis: reasoning models burn the token budget thinking and nothing is left for the answer. The fixes: a token ceiling with real margin, and a parser that tolerates a data: [DONE] glued to the JSON.

Two machines, the same code, the same key. One got 200, the other took a 403 with error code: 1010. No wrong token, no visible firewall rule: the filter looked at the TLS handshake and recognized the signature of an automated client before any request even existed. This post is about the identity layer that never shows up in application logs.

Arachne's response cache returned 'Brasília' to anyone asking about France — cosine 0.8531 against a 0.85 threshold. The story of a bug born in a CI investigation, the math that hid it, and the entity guard that fixed it without sacrificing recall.

Hitting the publish button used to make two commits: one flipped the frontmatter, the other regenerated the panel's index. In between, the panel listed a post that was already public. The fix was to stop chaining calls and ship everything in one commit through the Git Data API — blobs, tree, commit and ref, with a retry that re-reads the state of the world before trying again.

Nine libraries, a test runner major bump and a GitHub action updated in a single day. What it took to merge 11 dependabot pull requests on the Portfolio without breaking the suite — and the one that almost turned into a false alarm.

Before swapping Arachne's search engine for Yurumi, I had to prove the new one was at least as good as the old. Shadow dual-write, real traffic, overlap@10 — and the number nobody expects: 0.511.

79 tests green one day, 4 failing the next, zero production changes. Arachne stacked three different flavors of flakiness in 48 hours — and each one required a different knife: random vectors, network escaping the mock, and an assert that never ran.

The post was hidden, its route returned 404, the feed didn't mention it. It still showed up on the site: in the header of a tag page that was counting the wrong posts. The lesson is older than it looks — every new page that lists content is a new door, and frontmatter doesn't protect itself.

A test was deleting RAG tables on teardown. One run, the environment variable pointing at the isolated database was ignored by the engine — and the DELETE landed on the production arachne.db, with the live server writing to it. What saved the data was an error message.

A catatonic BitMamba 1B — broken tokenizer, 10^18 gradients, a midnight ENOMEM and a CUDA wedge that faked a dead GPU — closed 500 steps and the validation reproduced the eval loss to the fourth decimal. The diary of Phase 4B on a 12 GB RTX 3060.

PataPass was a website wearing an app costume — and the browser made that obvious at the worst possible moment: inside an elevator with no signal. The story of Phase 4F: an install banner driven by beforeinstallprompt, an offline page served by the service worker, and the decision to never cache HTML.

The cover was remade twice, the deployment served the new bytes — and the blog kept showing the old image. The culprit wasn't the build or the CDN: it was a header promising the file would never change for a year. The story of the hunt, the math of immutable caching, and the rule that stuck: reworking an asset requires a new URL.

The Capivara light theme had washed-out text and a truncated email in the header. Static scanners stayed green, because none of them can see pixels. The one that caught it was a vision AI running screenshots of the real dashboard — and the patch was swapping hardcoded values for theme tokens and giving the layout room to breathe.

I resumed a run from the last checkpoint and it looked healthy — steps advancing, gradient in range, zero errors. Except the learning rate had quietly shrunk by three orders of magnitude. The cause: the LR scheduler restores more than it should when loading old state, and the fix was two lines.

The reject-post button saved feedback to a file. But a file doesn't open an issue, doesn't notify, and doesn't nag. One day the silent queue swallowed an entire request — and LifeLog learned that rejection without notification is just polite disposal. The story of /api/recusar and the loop that closes itself.

React hydration error #418 in the portfolio footer, a mystery that only happened at night: the server renders in UTC, the visitor in local time, and a new Date() in JSX gave each of them a different answer. The hunt for the useState(null), the pinned timeZone, and the epilogue where I myself created a second bug while fixing the first.

After a reboot, everything came back green: process up, health check passing — and the page wouldn't open from anywhere. The service had resurrected with instructions from a past life, frozen in a state file, while the world outside had moved. This post covers the hunt, the fix at the source (stale state dies on every start, address defined in exactly one place) and the second half of the story: a network announcement that only talked to an interface with a fixed name, on the day the system renamed it.

On August 11 I put a secret scanner on this blog's pipeline. The next day it flagged a build cache file as if it were a key. I silenced it with an entry pinned to that finding's exact fingerprint. Sixteen days later I had to come back to the same spot and write the exception again, this time as policy. That gap is the difference between suppressing an event and defining what should never alarm in the first place.

The status button finally worked within the session — but an F5 wiped it all: a reload brought the walker back offline for the entire system. The direct sequel to the ghost button: real persistence of the online status, from the frontend down to the profile PATCH.

The Arachne landing page loaded without CSS, the watchdog restarted the service in an invisible loop, and a zombie socat relay kept stealing the port from its rightful owner. Three chained bugs in a single diagnosis — and the lesson that a 'stopped' service can keep causing damage.

The new stage in my transcription pipeline uses Gemini TEXT over 120s windows — no audio, cheap and fast. What keeps the model from making things up isn't a polite prompt: it's a numeric ±35% character invariant per window, with retry and flag when the math doesn't close.

After the bilingual jump to 0.1614 recall@1, there was a number left on the bench: how much was the cross-encoder contributing on every search? The week I measured that latency and recall are a bill you pay on every query — and the answer ended up written as a permanent flag in the config.

Gitleaks, bandit and opengrep ran weekly and everything stayed green. Even so, a single GET request returned the entire .env in production. The hole wasn't a committed secret — it was a path my own code opened. And the one who found it wasn't the scanner.

The Phase 4 run dropped mid-flight with no traceback, no OOM, no error log: the process simply stopped existing. Chasing the cause turned into a lesson about watching the wrong metrics — and about the invisible cost of letting your GPU driver sweep up your garbage.

The alarm hunts, the gate blocks, the dog attacks. But there is a fourth layer in my security setup that nobody wrote about: the dependency update queue. On August 31st, the bot delivered five fix proposals. Three days later, all five are still open. The queue became the surface.

The portfolio hero typed, erased, and retyped — not as an effect, but as a bug: deferred hydration mounted the component and reset the text already on screen. The story of how LCP dropped from 3.6s to 2.7s by removing idle-hydration from the wrong place.

The walker toggle 'Go Online' rendered, animated, and even changed color. But the handler was an empty function: the state never left 'online'. The story of how a test loop caught a ghost button and gave back real online status.

300 training steps, a loss stuck at 10.8125, and a model that insisted on coming out blank. The cause wasn't a low learning rate — it was exploded weights in the starting checkpoint. The story of how a stalled run became a full diagnosis.

Cover gate at build time, WCAG AA contrast, the 10th project in the schema, and a bug-hunter audit with zero violations. The story of how a blog stopped being just a blog and became a quality system.

A brand-new CRUD in the personal hub, with groups, priorities and status — and a silent bug: the apiFetch helper already prepends /api, and I called /api/pedidos on top of it. /api/api/pedidos was born, and nobody saw it.

A study about cron jobs: why they accumulate, fail silently, and how a cron that 'never sleeps' can take down an ecosystem. From Yurumi's consolidation to 289 orphan jobs — the lessons from a night of investigation.

Yurumi started as a local replacement for mem0 — storing conversation memories. In two weeks it gained intent, actions, learning, its own identity and a knowledge graph. The journey from a simple store to a complete agentic system.

The codec post ended with a dangling issue: the lm_head diverging in validation. Two weeks later, a methodical audit rescaled the model's head, generated a clean checkpoint, and became the foundation of Phase 4 — the Resurrection.

Ten days after automating active hunting, I realized the problem wasn't finding flaws — it was making sure nothing shipped without a security review. The security gate was born not as a tool but as a process rule: before any delivery, the test loop must pass. And the loop includes a dedicated security reviewer.

A Reject button in /ocultos that writes a note, opens a GitHub Issue, saves a file to the repo, and a 15-min cron redoes the post by itself. The story of how human feedback became a pipeline.

Three embedding models, two search systems, one homegrown benchmark: the study that started with a question about semantic similarity and ended up revealing the tradeoffs between colibri, bge and openai — and how each one found its place in the ecosystem.

Capivara kept its memories in a local ChromaDB, with its own embedder and L1-L4 layers. Yurumi kept the ecosystem's memory in a Qdrant. Two separate memories meant a brain that never talked to the rest of the body. The unification on 08/28 migrated 182/182 memories without losing a single one: hash dedup, backup before deleting, and an --apply gate that separates the plan from the execution.

Every public site has a front door: the contact form and the resume download. Two endpoints that accept input from strangers on the internet — and I finally treated them as such. Rate limiting, HTML escaping, a contact file for people who find flaws, and a scanner that watches everything in silence.

The home dashboard used to load section by section, and I still had to assemble the big picture in my head. Enter the Executive Hub: one endpoint aggregating projects, backups, alerts and infra in a single call, with graceful failure and zero SSRF.

The axe-core report left no room for excuses: 92 contrast failures, buttons without accessible names, selects without labels, blocked zoom on the onboarding page. In two days Arachne went from 60 violation nodes to zero across 16 routes — swapping color tokens, adding aria-labels, and learning the hard way that Cloudflare immutable serves stale CSS and that code-split SPA CSS doesn't live where you expect it.

Every project's AGENTS.md was the official instruction set of the ecosystem, but it lived outside the Yurumi's memory — the ingest only ran when someone remembered to run it. The fix was a signature watcher (mtime+size) that re-ingests only what changed. Along the way: a first_run that ran a full ingest every day, an os.stat that hung when WSL wedged, and the lesson of never trusting a junction.

When the theme toggle animation revealed the old theme instead of the new one, the fault was not in the CSS — React had not committed the state in time.

After mapping the port inventory, the next step was planting bait: fake services, deliberately outdated in appearance, that pose as easy targets. A watcher classifies every touch on the log, and the central dispatcher decides when a detection becomes a notification.

An accessibility audit on LifeLog turned into a hunt for four contrast traps: code comments at 3.9:1, project badges failing in 4 of 6 palettes, a theme selector that Astro scoping silently broke, and the alpha that axe-core refuses to compose. The result: 14 routes x themes with zero serious/critical violations.

The simple question 'what does my agent actually remember?' turned into a full audit of Yurumi: 32 knowledge bases, 551 documents, a Qdrant collection with over 8 thousand vectors, and a LoCoMo baseline that handed back reality in percentage form.

The cover watchdog I built to guarantee good images on the blog found a problem I didn't expect: the AI-generated covers arrived in the wrong format. The browser rejected them, and I only found out because the watchdog itself complained.

One of the most underestimated layers of security is knowing what is open. The watchdog keeps a living inventory of ports, services and bindings — mapped against what is intentional — so any new port looks abnormal in seconds.

I actually read the BitNet b1.58 paper and got stuck on a math problem that refused to add up: how do three values (-1, 0, +1) fit in 1.58 bits? A study week that became a didactic clone of ternary quantization — and wrecked my mental model of 'precision equals quality'.

A repo that accumulates build artifacts and syncs doesn't tell the clean story you want to show. TatuEngine went through versioning hygiene: build artifacts out of git, auto-sync running, and a repository ready for outsiders to look at without handing over the internal recipe.

The second brain got a brand-new theming system: a ThemeProvider with design tokens, CSP-compliant anti-flash, and per-project palettes. Along the way, the email service quietly broke because the Resend domain was wrong — and invites started arriving again.

The security watchdog stopped feeding a kanban nobody read and started publishing findings where they matter: into persistent memory and the right channel. Less ceremony, more active hunting, zero cards.

Four commits in a row touching the LifeLog navbar, each one undoing the effect of the one before it. Links that disappeared, a logo that jumped away, a button that floated on its own. The lesson: refactoring in a hurry across a jumble of classes is like baking a cake while changing the recipe at every step.

Predictive navigation in Arachne: the agent receives a page image, predicts the whole next chain of steps, and executes end-to-end. D→C→B→A fallback cascade, real browser_agent driver, scraping link and WebSocket broadcast on the Cockpit.

A wrong Cache-Control header in vercel.json was overriding the revalidate=1800 ISR setting and turning every cache expiry into two synchronous GitHub calls inside the TTFB. The story of how cold cache became warm: 3.6s down to 140ms.

After the wave field theory and Mamba post, the theory gained something it was missing: a didactic, portable, testable artifact. How to turn a study into code that runs — and why that changed how I learn.

The LifeLog E2E suite started failing with 'Expected "" Received "estudos"' on 24 assertions. It wasn't a visual bug — it was the test helper drifting from production logic: it didn't filter hidden:true posts, and the frontmatter regex didn't match the CRLF line endings of the .mdx files. A story of how a test becomes the source of truth when it stops mirroring production.

The Security Agent cross-references findings from two hunters — the Dogwalk Bug Hunter and the Security Hunter watchdog — and outputs a single deduplicated alarm. A health gate to filter infrastructure false positives, discarded network error patterns, local-state dedup, and the no_agent contract: silence when everything is healthy.

Arachne's vision pipeline evolved: qwen2.5vl:7b on Ollama WSL, arachne-vlm-jobs queue with arachne-vlm-w1 worker, SQLite vlm_cache.db cache (sha256), polling GET /api/extract/image-jobs/{id}. Vision requires JWT, PYTHONPATH api/ and PostgreSQL not SQLite.

ZAP, gitleaks, bandit, opengrep running across all 7 ecosystem projects. What the active hunt found: unlocked database, excessive browser permissions, route leaking data without checks, exposed key, untreated input. And the watchdog now monitoring 24/7.

A post that went live with a dark cover made me build a guarantee system: image generation with a two-layer fallback and a silent watchdog that swaps bad covers by itself. The story of how the blog stopped depending on a single path.

The portfolio's projects section almost got a category filter. It didn't — and that was the best decision. The story of a 2-column grid that resisted the lure of complexity.

Local services hanging intermittently: Qdrant on port 6333, helper APIs — everything pointing to 'localhost'. On Windows, 'localhost' resolves to IPv6 (::1) first — and the connection hangs. '127.0.0.1' forces IPv4 and works. Confirmed 88 times until it became a rule: always use 127.0.0.1.

The ecosystem's security went through 3 phases: the ai-jail that sandboxed the agent (bwrap + landlock), active vulnerability hunting (ZAP, gitleaks, bandit, opengrep across every project) and the automatic watchdog that monitors what nobody looks at. 2 posts so far — and this is the full story.

Out of 78 posts, only 1 was about studies — the Ollama truncation loop. But it was in the studies that wave field theory, Mamba SSM and the BitMamba-2 1B were born. The story of what the blog's most neglected section actually produced.

TatuEngine had 5.7GB of AI models committed to git since day one. GitHub rejects objects above 2GB with a 422 error — that push would never succeed. The fix wasn't 'pushing through': it was an orphan branch that preserved code, tests, and docs and rewrote the repository's history from scratch.

BitMamba-2 1B's in-engine inference representation was unworkable in memory. A compact ternary block codec delivered orders of magnitude of savings, with the lm_head diverging mid-validation.

The script logged Docs backup, but the tar held only 53 of 218 files — an overnight OOM swallowed by 2>/dev/null.

Arachne ran 10 services on Docker Compose. Kubernetes showed up on my resume as a desired keyword — but I didn't use it. Instead of lying, I decided to adopt k3s for real: single-node, with a phased plan, guaranteed rollback, and RAM metrics as the stopping criterion.

pnpm audit on the Portfólio screamed 61 vulnerabilities. Instead of updating dependency by dependency or trusting audit fix, I solved it with 5 lines of pnpm.overrides in package.json. Result: 61 → 2, with the remaining 2 having no published fix at all.

After finding 28 hardcoded PT texts scattered across the Portfolio (buttons, aria-labels, modals, tracking), I created an audit test that scans components and fails CI if any Portuguese text appears outside t(). The lesson: old tests were anchored to the bug — they searched for literal PT text instead of the i18n contract.

Home cards used to show the historical event date — and the order looked messy (07, 09, 09, 06). The change: show the publish date (pubDate). The story of a detail that changes how the blog is perceived.

Stripe with dead DNS 500s, a Portifolio Staging that no longer existed, a rate limit that blocked the wrong IP. The surgical cleanup that made the Capivara dashboard tell the truth again — and the CF-Connecting-IP that actually fixed the rate limit.

In the early hours, Arachne woke up intermittent: the scraping workflow failed with 'browser agent not available in this worker'. The journal showed a cryptic RuntimeError: the browser pool lock was bound to an event loop that wasn't the worker's. The cause: asyncio.Lock() created at import time. The fix: lazy init — born inside the right loop.

TatuEngine got a punishment layer v3: progressive fines for repeat offenses, partial cold restart, automatic tool denial and output reprimand. The idea: instead of only rewarding good behavior, punish bad behavior with growing intensity — like an immune system that learns from every mistake.

The Capivara Dashboard had 994 lines and was impossible to maintain. Refactored to 262 (-74%), the initial bundle dropped from 668 kB to 238 kB (-64%) with React Router + lazy loading. The lesson: a giant component isn't a feature — it's disguised technical debt.

Arachne responded 200, but authenticated routes rendered empty. A Bug Hunter found 1,239 QueuePool errors in the journal since 02:57. The cause: a session generator that was never closed — each request leaked an idle-in-transaction connection until the 30-connection pool exploded.

All Dogwalk WebSockets returned HTTP 500 on handshake. The app ran, the database responded, but real-time login, chat and walk tracking simply wouldn't connect. The cause: a receive_text() called without the accept() Starlette requires.

Five days trying to make a circle of light start exactly where the finger touches. The CSS looked right, CI passed, but the user saw stutter, wrong origin, and content wiping out. The root cause wasn't the code — it was the interaction between the View Transitions API, Chromium blend modes, and a ghost node_modules.

Portfolio was 100% functional, 218 tests passing, zero CI errors. But mobile Chrome users saw old versions when restoring tabs. The cause: Chrome's bfcache ignores HTTP headers — and the fix came cross-project from LifeLog.

Automating narrative posts seemed simple: a cron, a script, a preview. On the same day, the pipeline hit 4 real walls — pnpm blocked by the gateway guard, MDX breaking the build with '<', a 0-byte cover and an interrupted session. Each wall became a rule.

After learning to infer (252× GPU speedup), TatuEngine went for the Master-Apprentice cycle: a Qwen2.5-3B teacher with LoRA distilling structured reasoning ([THOUGHT]/[ANSWER]) into the BitMamba-2 1B student. Six versions in one day (v0.17→v0.22.2), 381 examples, and the convergence that wouldn't come until the system message fix.

Nobody touched the code, yet Vercel kept rejecting the build: ERR_PNPM_EEXIST. The cause: a security cron ran pnpm audit fix with the Windows pnpm, regenerated a v10 lockfile while packageManager declared 9.12.3 — the saga of aligning local pnpm, packageManager and CI.

The personal hub was returning intermittent 502s on the tunnel. The fix: mirror Capivara to the backup machine (fallback) with one-way sync and healthcheck — and prove it with a real failover test: The primary node's cloudflared stopped for 40s, site 5/5 = 200, the backup machine took over by itself.

MCP became the universal connector (published on the official registry), FTS5+vector became hybrid search with RRF, ai-jail isolated the agent and Ollama brought AI home — and the lessons became rules: docs first, plan first, stop and ask.

Born from the absurd question 'what if we used RT Cores to process neural networks?', killed the dream on WSL2, and became a hybrid CPU/GPU engine with BitMamba-2 1B, radical compression, an agent with 8 subsystems and a security sandbox — 302 commits later.

529 commits, 218 tests, 5 mini-games, multi-layer parallax scene, interactive terminal with 15+ commands, full PT/EN i18n — the journey of a portfolio that became an interactive showcase.

107 commits, 131 backend tests + 248 frontend, 2FA TOTP, local RAG with ChromaDB, R2 backup and D1 disaster recovery — the saga of turning a personal dashboard into reliable infrastructure.

777 commits, 2818 tests, hybrid RAG, ReAct Agent with 42 tools, MCP server, and the evolution from a simple scraper to a knowledge platform.

970 commits, 1456 tests, Stripe Connect, Open Design, and the saga of turning a pet marketplace into a platform that doesn't break on deploy.

158 commits, 50 bilingual posts, 4 theme engines, 59 AI covers, and a decision that changed everything: killing the bot that wrote posts on its own.

In July, 8 commits improved Hermes' computer use: permission modes, desktop control, voice barge-in. The code exists — but on WSL, an X11 server is still needed to actually run it.

298 commits, zero new features in 30 days, and an SSM inference engine that runs unsupervised. The TatuEngine doesn't need changes — it just works.

When your engine runs AI-generated code, you need a sandbox that doesn't hinder development but won't let path traversal slip through.

Broken Pix BR Code, focus trap stealing keyboard input, scroll jumping sections — a deep audit fixed everything at once.

July 2026 was the month my portfolio stopped getting new features and started fixing the ones it already had. A deep audit revealed 10 problems — from Pix to focus trap — and by the end, deployment was more automated than ever.

Hermes kept entering a continuation loop 4 times before giving up. The cause: Ollama, by default, only allocates 4096 context tokens — regardless of the model supporting 262K. The hard way: num_ctx of the model ≠ num_ctx of the inference slot.

My Hermes agent has access to everything: API tokens, Stripe keys, database credentials. One wrong terminal() command and it all leaks. The fix: a Rust sandbox that isolates every execution with bubblewrap, Landlock, and Seccomp.

I added Pix to my portfolio with BR Code generation. Only the QR Code didn't work in any banking app. The culprit: String.fromCharCode generating control characters instead of decimal digits in EMV 2022 length fields.

Instead of replacing the circular reveal with basic crossfade, I fixed the root cause of stutter on low-end GPUs. VT clip-path + clean fallback.

The moment I realized my devlog blog was producing reports, not stories — and how I fixed it by killing the robot that wrote posts on its own.

Under the hood of an 83% frontend refactoring: Ghost Components, silent schema drift, the two-systemd war, the phantom Umami proxy, and other pains that don't fit in a changelog.

Exploring the current state of Capivara — learnings, challenges and discoveries.

Exploring the current state of TatuEngine — lessons, challenges, and discoveries.

25 MCP tools, multimodal vision with local AI, observability, billing, and the sandbox that made Arachne a platform — the current state of the project in July 2026.

Why I created a personal blog in 2026, the Astro choice, and what to expect going forward.

From 3 projects in June to 5 in July, the Samuel ecosystem now has 2,396 commits, 3,647+ tests, and one agent orchestrating it all.

Exploring the portfolio games — lessons learned, challenges and discoveries.

The saga of making Student BitMamba-1B learn without exploding: Adafactor vs AdamW, saving 4 GB of VRAM, and the 4 bugs that produced NaN during bf16 training.

Exploring hybrid search — lessons, challenges, and discoveries.

Exploring July's tools — lessons, challenges, and discoveries.

The journey (and the craters) of training a Mamba-2 with 1.4B parameters from scratch on an RTX 3060 — warmup, SFT, catastrophic eval, and Phase 4 of the resurrection.

Exploring D1 sync — learnings, challenges and discoveries.

How Capivara solved the financial mess of multiple accounts, spreadsheets and categories — unifying everything in one dashboard.

From zero tests to 853: how Playwright tests became the quality backbone of Dogwalk/PataPass, what we learned and what changed in the process.

JWT, Supabase, OAuth, refresh token, protected routes and conditional layout — the story of authentication in Dogwalk.

Exploring the beginnings of TatuEngine — lessons, challenges, and discoveries.

The real story of how a 200-line Python scraper became a platform with 740+ files, RAG, visual pipelines and 36 ReAct tools.

From messy spreadsheets to a full dashboard with real-time health checks, Umami integration, and financial analytics with spending categories. The evolution of Capivara from a simple personal hub to the ecosystem's control center.

Experimenting with Crawl4AI in Arachne: Docker Sidecar, Python SDK, comparison with Trafilatura, and the decision to use automatic fallback between engines.

Exploring the portfolio rebuild — lessons learned, challenges and discoveries.

How end-to-end tests transformed quality and confidence in Dogwalk's development — the real story of a stack that learned to test itself.

The architecture that actually solves web data extraction: Trafilatura, Crawl4AI SDK, Docker Sidecar, and Camoufox — how each layer works, the fallback criteria, and what I learned along the way.

Tired of scrapers that broke out of nowhere and expensive third-party services, I decided to build my own data extraction platform.

The simple scraper became a platform. Crawl4AI Sidecar, automatic 4-layer fallback, and SQLite cache with FTS5.

With 3 projects running, the infrastructure needed to be robust. Automated backups, security hardening, and the Hermes Agent as the ecosystem's brain.

After building tools for others, I decided to dedicate time to my own space. A portfolio that is more than a resume.

After the idea came the hardest part: getting your hands dirty. How I chose React, Vite and FastAPI to build Dogwalk.

Exploring the stack choice — lessons learned, challenges and discoveries.

After weeks of coding, it was time to put Dogwalk online. The first deploy was a mix of euphoria and frustration — Vite + Cloudflare Pages.