Home on Start AI Tools - Presented by Intent Solutions

Chapter 1 — AGENTS.md as a Cross-Tool Plugin Brief

Mon, 11 May 2026 07:00:00 -0400

Chapter 1 of 3 in Agent-Native Mobile Testing. Originally published as the daily post AGENTS.md as a Cross-Tool Plugin Brief: A Case Study from kobiton/automate. The chapter form adds connective tissue tying this case study into the broader series on plugin authoring, first-mover dynamics, and AI triage for agent-orchestrated mobile cloud testing.

TL;DR — A 5-device parity sweep against Kobiton’s real-device cloud through the kobiton/automate Claude Code plugin showed iOS screenshot capture ~17% faster than Android in this run. The interesting part isn’t the gap — it’s what an AGENTS.md file would close. PR #10 on the repo is starting to add one. This is a worked example of what should go in it.

Foundation Ship — Guidewire MCP v0.1.0

Tue, 05 May 2026 08:00:00 -0500

Source post: Guidewire MCP v0.1.0 — foundation ship

The phrase “minimum viable product” is a trap when you’re building infrastructure. MVP frames the conversation around what you can take out and still ship — which is exactly the wrong question for a server that other systems are about to depend on. Foundation is the better word: not the smallest thing that works, but the smallest thing that won’t have to be torn out and rebuilt when chapter two arrives.

Wild Ecosystem

Thu, 26 Mar 2026 12:00:00 -0500

The Wild Ecosystem

10 Ruby gems. ~2,924 tests. One mission: make AI agents safe in production Rails.

The wild ecosystem is a family of focused, open-source Ruby gems that together form a governed operational intelligence layer for AI-assisted development workflows. Every gem enforces safety by default — read-only where it matters, audited everywhere, bounded always.

Built collaboratively with Claude Code.

The Problem

AI agents are getting tool access to production systems. MCP is becoming the standard protocol. But most implementations give agents unrestricted access — raw console, arbitrary queries, no audit trail. One bad tool call mutates data. One expensive query kills a replica.

IRSB Ecosystem

Fri, 27 Mar 2026 12:00:00 -0500

The IRSB Ecosystem

3 layers. 37 contracts. ~1,200 tests. One mission: make AI agent transactions cryptographically accountable.

The IRSB ecosystem is a three-layer stack — protocol, policy, and brokering — that together form the first on-chain accountability layer for AI agent work. Every transaction produces an immutable receipt. Every solver posts a bond. Every violation triggers automated enforcement.

Built collaboratively with Claude Code.

The Problem

AI agents are getting wallet access. Every major framework — AgentKit, ElizaOS, Olas, Virtuals, Brian AI, Safe — gives agents the ability to sign transactions. None of them answer the question: what happens when the agent does something wrong?

Tests That Actually Catch Regressions

Tue, 05 May 2026 08:00:00 -0500

Source post: Anti-slop framework finds three bugs inside itself

A test suite that mocks the function under test is theater. It runs green, it produces coverage numbers, it makes the dashboard look healthy — and it catches nothing. The function it’s “testing” never actually executes.

The anti-slop principles are simple and they aren’t new. What’s new is treating them as a CI gate that an AI agent cannot escape:

Don’t mock the function under test. Mock its dependencies; let the function itself run.
Use exact assertions, not “is truthy.” A test that passes when the answer is 42 and also when it’s "42" is not a test.
Use asymmetric inputs. A test on add(2, 2) that passes returns 4 from a function that does a * b is a tautology.
No tautologies. assert(x == x) is not a test, even when x is a function call.

The bugs the framework found in itself

The post linked above documents three real bugs the framework caught when it was first turned loose on its own implementation. The most embarrassing one was a “happy path” test that asserted the wrong field — passed for two months before the framework’s own escape-scan flagged it.

Four Production-Deploy Gotchas

Tue, 05 May 2026 08:00:00 -0500

Source post: Four production deploy gotchas (companion: VPS-as-the-home Day 1)

Tests pass. CI is green. The merge is clean. You hit deploy and the production logs light up. Welcome to the seam where everything you tested doesn’t quite match where you’re running.

The four

Container image is built on a different libc than the host. Compiles fine, runs fine in CI, segfaults on the host because the prebuilt wheel was linked against musl and the host is glibc. Add an explicit base-image declaration to your Dockerfile and run a smoke test on the production image during CI, not just the host CI image.

AGENTS.md as a Cross-Tool Plugin Brief: A Case Study from kobiton/automate

Sun, 10 May 2026 17:00:00 -0400

Canonical home: This post first appeared on Kobiton’s blog at kobiton.com/blog/agents-md-cross-tool-plugin-brief-case-study-kobiton-automate. This page mirrors it; SEO authority consolidates to the Kobiton URL via rel="canonical".

AGENTS.md as a Cross-Tool Plugin Brief: A Case Study from kobiton/automate

TL;DR — I ran a 5-device parity sweep against Kobiton’s real-device cloud through the kobiton/automate Claude Code plugin. iOS screenshot capture came in ~17% faster than Android in this run. The interesting part isn’t the gap — it’s that the plugin doesn’t document the gap, or the post-deleteSession cooldown, or which Appium log endpoints actually work. That’s what an AGENTS.md file is for, and PR #10 on the repo is starting to add one. This is a worked example of what should go in it.

Spec graduation: when a partner email rewrites architecture

Sat, 09 May 2026 08:00:00 -0500

The cleanest architectural moves of the last six months didn’t come from a whiteboard. They came from a partner email that essentially said: hey, remember what we actually signed.

Yesterday’s post was about coherence as a deliverable — a full audit-day where four advisor agents independently flagged the same drift in the same engagement. The drift was real, but the post stayed at the diagnostic layer. It identified the misalignment without committing to the structural change that misalignment implied. Today is the structural change.

Coherence as a Deliverable: How a Multi-Surface Engagement Stays Sane

Fri, 08 May 2026 08:00:00 -0500

A sprawling multi-surface engagement (Kobiton partner pilot, 4 months, three deliverable rounds) exposed a silent failure mode: drift doesn’t announce itself. A title rename on Plane goes unnoticed when the canonical source doc still has the old framing. A partner-portal deliverable gets updated before the source file does, leaving future sessions reading stale context from what should be source-of-truth.

On 2026-05-08, one session caught two separate drift instances and shipped four structural patterns to make drift cheaper to find next time. None of the drifts were bugs. Both were coherence gaps — places where a single idea lived in multiple surfaces (Plane, beads, local docs, partner portal) with different currency.

Forge Dogfood Ships a Grade-A Plane Plugin, JRig Loop Closes

Thu, 07 May 2026 08:00:00 -0500

A plugin generator is theoretical until it produces something a marketplace will actually accept. May 7 turned the /skill-creator --forge workflow from an 8-gate diagram into a real artifact — a Plane plugin that scored Grade A (97/100), passed Tier 2 GREEN with zero warnings, and cleared all 12 deterministic j-rig checks across the 7-layer behavioral framework. On the same day, the JRig-Verified provenance pipe closed end-to-end: a schema, a build-time enrichment step, a per-plugin verification page, and a validator tier all landed in the same window. The thesis the day proves: compound commands and build-time enrichment beat raw API surfaces and runtime joins, and the way to find that out is to run the full pipeline once on something real.

Guidewire MCP: v0.1.0 → v0.1.1 in 76 minutes

Wed, 06 May 2026 20:30:00 -0600

Insurance carriers run on Guidewire InsuranceSuite — PolicyCenter, ClaimCenter, BillingCenter. Underwriters and claims adjusters spend hours navigating the UI to answer questions like “what submissions are waiting on me?” or “why isn’t the Acme account active anymore?”. The Cloud API exists, but it speaks REST verbs (GET /job/v1/jobs?subtype=Submission&status=Quoted&assignedTo=alice). LLMs route well on operator language and badly on REST verbs. So the tools are named like the question an operator would actually ask:

The Two Postgres Bugs the Tests Caught: A Real-DB Integration Test Case Study

Tue, 05 May 2026 08:00:00 -0500

Thesis

A “no mocks” testcontainers policy caught two production-fatal Postgres bugs in one test run. The first would have shipped silently and failed at runtime on every fresh tenant. The second would have shipped to staging and waited there for a real human approver to exercise it — late integration at best, production runtime at worst, depending on how strict the pre-deploy soak is.

The artifact is PR #92 in the Guidewire MCP repo: +1581 lines, -2 lines, 11 new testcontainer cases against a real Postgres 16 image. The tests failed on the first run, surfaced two distinct migration bugs, got the fixes, and now report 51/51 pass at the package level (40 existing + 11 new) and 115/115 across all 8 workspaces.

Guidewire MCP v0.1.0: Carrier-Native Server Blueprint

Mon, 04 May 2026 08:00:00 -0500

Guidewire MCP for Claude v0.1.0 is a carrier-native Model Context Protocol (MCP) server that lets a Claude Code session ask a Guidewire PolicyCenter, BillingCenter, or ClaimCenter tenant questions in the language an underwriter or claims handler would actually use — find-submissions-waiting-on-me, summarize-this-submission, did-we-lose-this-account — instead of the API verbs an integration engineer would reach for. The v0.1.0 cut shipped on 2026-05-04 as 30 merged PRs (+14,521 / -819 lines), comprising six foundation packages, five read-only PolicyCenter tools, a Claude Code plugin manifest, and a live architecture diagram on a custom subdomain. Alongside the code, ~30k words of blueprint documents — business case, PRD, architecture, user journey, technical spec, roadmap — landed in blueprint/ on the same day. (All 30 merged PRs are visible at github.com/jeremylongshore/guidewire-mcp-for-claude/pulls?q=is%3Apr+is%3Amerged.)

An Anti-Slop Framework Found Three Bugs Inside Itself on Day One

Sun, 03 May 2026 08:00:00 -0500

A framework whose entire purpose is to catch silent failures in AI-generated OSS contributions is the worst possible place to host silent failures. That tension is the spine of this case study. The framework in question is contributing-clanker, an installable Claude Code skill that walks an OSS contribution lifecycle through 41 deterministic gates spanning seven phases and 62 enumerated AI-slop failure modes. It shipped at v0.1.0 around 20:20 local time. By the end of the same day it was at v0.1.2 — because the first real qualifying flow against a third-party upstream (secureblue/secureblue#2138) surfaced three categorically named bash/CLI silent-failure modes inside the framework itself, plus a minor scoping bug already patched in v0.1.1.

Four production deploy gotchas: systemd, V8 JIT, tsc noEmit, Caddy

Sat, 02 May 2026 08:00:00 -0500

Two release cadences collided on the same day. One was a thoughtful CI redesign that finally broke a four-month npm publish freeze across 400+ packages — good engineering, well-trodden ground. The other was a fifteen-minute production firefight on mandy.intentsolutions.io that surfaced four cross-layer deploy gotchas you would never know to look for until they hit you. Five releases in fifteen minutes, six commits, four production fixes, and a sixth release for the next layer of the system. The firefight is the one worth keeping in your runbook.

Eight Deploy Iterations: Tailscale OIDC + Reusable Workflow

Fri, 01 May 2026 08:00:00 -0500

Day 1 of VPS-as-the-Home was the launch of a 9-priority program: consolidate Intent Solutions hosting onto a single Contabo VPS, execute the GCP exodus, and harden every active repo’s deploy posture. The deploy pipeline cost 8 GitHub Actions run iterations across two priorities to land what should have been one. The plan-v4.1 rewrite — adding testing as a first-class requirement after the user surfaced that cd <random-repo> && git push should “just work” — was the discipline that survived contact with reality.

April 2026: Tier 3 Finds Its Footing — Eight Case Studies, the Audit Harness Ships, and the Schema Postmortem

Thu, 30 Apr 2026 18:00:00 -0500

April was the month Tier 3 found its footing. March’s retrospective predicted “a natural T2 rate of roughly 5–10%” — about two to three deep-dives per month out of thirty. April blew past that. Of the eighteen posts that ran through the classifier, eight were Tier 3 case studies. Five of them landed at the top of the depth charts at three hundred lines or more. The teaching dimension scored a flat TCH=4 on every one of them — the highest score the rubric assigns short of “this changes the field.”

Propagation Day: When the CLAUDE.md Spec Becomes the Migration Plan

Thu, 30 Apr 2026 08:00:00 -0500

On April 30, three patterns that had been written into ~/.claude/CLAUDE.md weeks or months earlier as “TO-DO: propagate to all repos, then delete this section” all reached critical mass on the same day. The bd-sync three-layer mirror got its first real-world execution against 24 beads at the Braves Booth repo. The SOPS+age secrets standard flipped on in six repos via one idempotent helper script. The marketplace compatible-with → compatibility rename swept across 2,849 skills in one batch run. The numbers add up to the kind of graph that looks impressive in a screenshot — 3,000+ files changed, 45 PRs merged, 9 repos touched.

Forty-Four Minutes Before First Pitch: An LLM Fallback Chain and a Live Probability Gauge in One Session

Wed, 29 Apr 2026 08:00:00 -0500

TL;DR

At 22:31 on 2026-04-29, Groq’s daily token quota for braves-booth (on-demand tier, 100K tokens/day) blew through 96.7% with first pitch 44 minutes away. The site was up and the data was flowing, but the storylines pane — the LLM-generated narrative the broadcast actually consumes — was about to go blank. The fix that landed before the broadcast started was a four-stage fallback chain: NVIDIA NIM Llama 3.3 70B as new primary, Groq 70B as warm secondary, Groq 8B as cold tertiary, and a deterministic facts-only renderer as the final floor. By the time the chain was deployed and serving, the producer asked for a second feature — a live AB-by-AB Monte Carlo probability gauge tracking a named on-air prediction by executive producer Jonathan Chadwick. JChad’s Challenge shipped in the same session, prior-art-checked, math-modelled, and live on the dashboard before the third inning. The thesis of this post is that when your free LLM tier dies 44 minutes before a live broadcast, the resilience pattern is the product. The same posture — ship the floor, then ship the feature — carried us from incident response into a genuinely novel artifact in one window.

The Rubric Sits On Top Of The Spec: A Schema Validator Postmortem

Tue, 28 Apr 2026 08:00:00 -0500

When you author a stricter enterprise rubric on top of a permissive open spec, the rubric must sit additive on top of the spec — not replace its required-field set with the spec’s floor. Demoting required-field errors to warnings to “realign with the underlying spec” breaks the marketplace gate it was built to enforce.

That sentence is the entire lesson from a multi-hour debacle on April 28th. The rest of this post explains how a confident plan to “realign the validator to Anthropic’s authoritative sources” tore down a working enterprise rubric, what got caught mid-flight, what survived the rebuild, and the NON-NEGOTIABLES section now pinned at the top of SCHEMA_CHANGELOG.md so it doesn’t happen again.

Service-Layer Scrub: Removing n8n from Intent Solutions Landing

Sun, 26 Apr 2026 08:00:00 -0500

Removing a vendor from your positioning isn’t a single find-and-replace. It’s a service-layer scrub: hunt every passive mention, rewrite the comparison surface, fix every internal link, and ship it all in one coherent commit so the story stays intact.

On the intent-solutions-landing repo, n8n needed to come out. The landing site had positioned it alongside Vertex AI in the automation stack, but the current narrative no longer claimed Jeremy actively uses it. Passive mentions lingered—stale context that muddied the signal.

Three Parallel Threads: Ground Truth Checks

Sat, 25 Apr 2026 08:00:00 -0500

Friday stacked three parallel threads across the Braves Booth, CAD agent, and Intent Solutions landing site — three different codebases, three different problems. They had nothing in common except one operating principle that caught them all: ground truth checks before committing.

Braves Booth: Wiring in a Beat Reporter

Lindsay Crosby (@crosbybaseball) is the Managing Editor of Braves Today and host of Locked On Braves. User asked to wire her X handle into the beat-reporter feed. Obvious move — add to beat-reporters.json, push. But first: verify she’s not already in the system. Checked the RSS feeds. She was already pulling two-thirds of the way in through Braves Today and Locked On Braves — articles and podcast episodes both flowing. Her “Today’s Three Things” posts hit postgame routing correctly via regex. The missing piece was the X handle, and only the X handle. Ground truth = she’s nearly wired already; the add was surgical. Branched per safety rail, added the handle, one clean commit. Done right because we checked first.

Five Deployment Blockers, One Breakthrough: When to Check Memory Before Reaching for New Infrastructure

Fri, 24 Apr 2026 08:00:00 -0500

The Problem

I needed to share a dental-billing MCP architecture diagram with stakeholders. Not tomorrow. Now. It was a static HTML file — should be five minutes to get it online.

Instead, I hit five sequential blockers. Each one seemed independent. Each one cost time. By the fifth, I was deep in DNS cache debugging, TTY/GPG authentication issues, and wondering if I should just build a new demo subdomain from scratch.

Ending a Four-Month Silent Fail: Cross-Repo Triangulation on a Broken Gemini PR Workflow

Thu, 23 Apr 2026 08:00:00 -0500

When an integration silently fails for months, your first-principles hypothesis is the suspect — find a working reference implementation in the same ecosystem and triangulate against its actual configuration before committing to a fix.

That sentence is the whole lesson from today. The Gemini PR review workflow on claude-code-plugins-plus-skills had been silently failing on community PRs since December. Five contributor PRs were stalled with zero Gemini output. The pipeline’s gemini-review step kept reporting green. No one noticed because Gemini’s failure mode is “post nothing” — not “throw an error.”

Idle-State Polish, Duplicate-Rule Enforcement, and Marketplace Cleanup

Wed, 22 Apr 2026 08:00:00 -0500

A maintenance day across four repos — broadcast tooling, policy engine, marketplace, and a renamed agent. Each fix small, together readable in a minute.

braves — idle-state trimmed, feeds added, error boundaries landed

The broadcast dashboard spends most of a Braves off-day in “idle” mode. Over the last two weeks idle has accumulated sections that made sense once and don’t anymore. Cleanup day:

Remove Post-game Audio section (ad533bb) — the audio embed was stale 90% of the time and the 10% it worked duplicated the on-page MLB postgame block. Gone.
Remove MLB postgame block, dedupe score header (426afa9) — the idle GameStateBar was rendering a second score header under the main one. Single source of truth for score data.
Restore TOP PLAYS, kill idle GameStateBar (36e2e57) — TOP PLAYS had gotten dropped during an earlier refactor and nobody noticed. Back in, GameStateBar out. Net: fewer elements, more signal.
Add Just Baseball + Braves Journal feeds, fix header placement (cf842d8) — two new article feeds slotted into the idle layout. Just Baseball for analytical coverage, Braves Journal for beat reporting. Header placement had been drifting below the feed cards on narrow viewports; anchored to top of column.

The more interesting commit was cfb9f28 — root and per-panel error boundaries. A single JS exception in any panel was blanking the whole dashboard. With per-panel boundaries, a broken podcast feed stays broken in its own card while the score, live narrative, Reddit hype, and article feeds keep rendering. Error boundaries are one of those React features you skip until the first time a panel crashes during a live broadcast. Then you add them on principle.

Enforcement Travels With the Code: Shipping @intentsolutions/audit-harness v0.1.0

Tue, 21 Apr 2026 08:00:00 -0500

Testing policy that lives in ~/.claude/ is testing policy that dies on a fresh clone.

For the last six months the Intent Solutions repos have shared a common /audit-tests and /implement-tests skill pair — seven-layer taxonomy, RTM/personas/journeys, CRAP-score gates, escape-scan, harness-hash pinning. The skills did the enforcement from my workstation. That’s fine until someone else clones the repo. Then the pre-commit hook that references ~/.claude/skills/audit-tests/scripts/escape-scan.sh is gone, the CI job that validates the RTM is gone, and the policy that said “tests must kill 80% of mutants” is a markdown file nobody’s workflow actually consults.

Manifest System + Mutation Testing: Two Ways to Find Out What Actually Works

Mon, 20 Apr 2026 09:00:00 -0500

You can ship a feature that looks tested and isn’t. April 20 was two coordinated answers to that problem.

On one front (claude-code-slack-channel), the bot-manifest protocol’s publish side landed — the second half of a protocol whose consumer side had shipped on April 19. The same repo set a Stryker mutation baseline, killed the top-5 mutation survivors on its security primitives, and added a TypeScript-aware cyclomatic-complexity gate to CI. On another (claude-code-plugins), mass-publish infrastructure for the npm catalog scaffolded — scaffold-every-package-json generator, mass + incremental publish workflows, a SIGPIPE fix for the enumerate step. The narrative thread is the same across both: don’t trust that something works until an adversarial check tries to prove it doesn’t.

Four Releases in One Day: How the claude-code-slack-channel Security Sprint Actually Shipped

Sun, 19 Apr 2026 08:00:00 -0500

Four releases in one day is what happens when a security audit turns productive.

claude-code-slack-channel — the MCP server that lets Claude Code operate inside a Slack thread without leaking outside of it — cut v0.5.0, v0.5.1, v0.6.0, and v0.7.0 on April 19. Four tagged releases, 62 merged PRs, four named epics. No all-nighter. No heroics. Just a sequence where each release unblocked the next and the scope was strictly bounded.

LLM-as-Reducer and the Case for Killing the AI Label

Sat, 18 Apr 2026 10:00:00 -0500

A live broadcast tool shouldn’t die the moment the final out is recorded. Audiences stick around. They pull up YouTube for the post-game press conference that uploads 20 minutes later. They tune into podcasts, scroll Reddit threads, check what beat reporters and fans are saying on X. Your dashboard should meet them there.

The problem is that post-game signal comes from five different places, each with its own timing and noise floor. YouTube videos trickle in. Podcast feeds update on their own schedule (one might drop an episode at 11 PM, another at 6 AM the next day). Reddit threads sprawl with profanity, in-jokes, and takes that would make a talk-radio caller blush. Beat reporters and fans fire off takes across X at all hours. Synthesizing that into a useful surface seemed like three weeks of work.

Four Primitives, Three Reviews: How a Contributor PR Reshaped a Roadmap

Sat, 18 Apr 2026 08:00:00 -0500

TL;DR

claude-code-slack-channel v0.4.0 shipped Casey Margell’s allowBotIds PR on 2026-04-18. The merge forced a direction question the roadmap hadn’t yet answered: with peer bots now able to deliver into the channel, what is the project becoming? Four issues were filed in response — thread-scoped sessions (#32), a declarative policy engine (#29), a threaded action journal (#30), and a bot-manifest protocol (#31). Before writing a single line of code, the project ran the four proposals through prior-art research and three independent review passes. The reviews converged on a narrower v0.5.0 than the issues proposed: ship #32 first, then #29, defer #30 with a reframed scope, push #31 to a later release conditional on external signals. This post is a case study in that process — not the roadmap itself, but how the roadmap got reshaped.

Pre-Warmed Narratives, Stat Digests, and a Community PR

Fri, 17 Apr 2026 10:00:00 -0500

Two repos, two small wins.

Braves Booth: Kill the Spinner

The dashboard generates AI narratives about batters and pitchers in real time. That’s expensive—Groq Llama 3.3 70B takes 2–3 seconds per narrative—and it was blocking paint. Viewers opening the page mid-broadcast saw spinners.

The fix was already half-built. The event bus already emits game-discovery (when the lineup is set), batter-change, and pitcher-change events. The concurrency pool was in place. The narrative cache existed. So: pre-generate everything the moment you know the game state. On game-discovery, warm narratives for the full lineup vs the opposing starter. On batter-change, pre-generate for on-deck and in-hole. On pitcher-change, re-fetch for all visible batters.

AI Code Review Blind Test: Where 5 Bots Shine

Thu, 16 Apr 2026 08:00:00 -0500

The result, up front

Five AI review bots running blind against 74 real open-source PRs hit 63.5% agreement with what the project’s maintainers actually did. No Slack, no roadmap, no release-timing context. Just the diff, the bot consensus, the test suite, and Claude Code synthesizing the verdict. Every review artifact was written by the pipeline; the human role was a final approval gate before anything would have been submitted upstream, which never happened.

The 35x FLOPs Error That Peer Review Predicted

Wed, 15 Apr 2026 10:00:00 -0500

Peer review is not paperwork. When a reviewer tells you “unchecked derivations are your highest-risk failure class,” they are handing you the exact failure that will bite you if you skip the checklist.

On April 15 a FLOPs figure in pre-filing patent artifacts for QCSS quietly moved from 19M to 679M — a 35x underestimate — exactly the class the reviewers flagged. Elsewhere in the portfolio that same day, cosign and SLSA provenance shipped for a daemon image, an 11-dimension code-cleanup plugin landed, a 5-agent research chain got recoverable failure states, and a marketplace shed 24,884 lines of obsolete scripts. Different projects, same pattern: systematize against the failure classes you can name.

Repo-Resolver: Typed Errors and Monorepo Detection

Tue, 14 Apr 2026 10:00:00 -0500

Three different services in the qmd-team-intent-kb stack all need to answer the same question: “what repo is this?” The edge-daemon needs it at spool time to tag captured memory candidates. The MCP server needs it at query time to scope retrieval. The ingestion pipeline needs it at index time to build canonical tenant partitions. Before April 14, each of them had its own half-answer — resolveGitContext() variants with different edge-case handling, different caching strategies, and a long tail of bugs around SSH vs HTTPS remotes and monorepo roots.

Twenty-One Documents and a Weak Reject: Building a Research Corpus for a Novel Search Architecture

Mon, 13 Apr 2026 10:00:00 -0600

Every vector search system you have ever used assumes the same thing: that someone already ran every document through an embedding model and stored the results. For most workloads, that assumption is fine. For some, it is fatal.

Forensic seizure of 50TB of unstructured data. A due diligence data room that exists for 72 hours. Medical records under privacy regulations that prohibit persistent derived representations. In these scenarios, the hours required to build an embedding index are the problem. You need semantic search over raw text that was never preprocessed, and you need it in minutes, not days.

Groq on Cloud Run, a Dep Bump, and a Star Refresh

Sun, 12 Apr 2026 10:00:00 -0600

Production was calling Vertex AI. It was supposed to call Groq.

April 12th was a three-commit day across three repos. No new features. No architecture decisions. Just the kind of small, necessary fixes that keep things running correctly.

The Missing Environment Variable

The braves broadcast dashboard uses Groq for LLM inference. Locally, everything worked. The GROQ_API_KEY env var was in my .env file, the Groq client initialized, responses came back fast. Ship it to Cloud Run. Deploy succeeds. Dashboard loads.

Twelve PRs, a Security Sprint, and a Pregame Overhaul

Sat, 11 Apr 2026 10:00:00 -0600

The Braves pregame view was a skeleton. Team names, probable pitchers, a few bullet points from a language model that silently failed half the time. Announcers had to Alt-Tab to MLB.com for anything useful. Meanwhile, a security researcher opened a PR on claude-code-slack-channel showing that the file-upload guard was checking the wrong thing entirely – blocking uploads from the plugin’s own state directory while allowing ~/.ssh/id_rsa through without complaint.

Both problems needed to be fixed before the weekend. Both got fixed in one day.

Pregame Storylines Stuck Forever and a Docs Sync That Should Have Been Boring

Fri, 10 Apr 2026 10:00:00 -0600

The Braves Booth pregame view had a spinner that never stopped spinning.

Open the dashboard before a game. The lineup loads. The matchup previews load. The storylines section says “Generating storylines…” and stays there. Forever. No error. No timeout. Just a loading state that never resolves.

Two repos got commits today. One was a real bug. The other was a docs consistency audit. Maintenance day.

The Cache-Only Read

The pregame route fetched storylines with a synchronous cache read:

Slack Channel v0.2.0: Security Hardening and Two External Contributors

Thu, 09 Apr 2026 10:00:00 -0500

Two people you’ve never met submit PRs to your project. Their code is anywhere near the permission relay — the component that decides what Slack users are allowed to do. This is the part of the codebase where “move fast and merge” is not the right instinct.

claude-code-slack-channel v0.2.0 shipped with five commits: three for security hardening on the permission relay, and two external contributor PRs from SamSchimek and Lingnik. Plus a single cross-publish commit pushing the April 6-8 field notes to the Intent Solutions landing site.

Knowledge OS: Render, Promote, and the Research Command

Wed, 08 Apr 2026 10:00:00 -0500

Three days ago ICO was at v0.1.5. Today it’s at v0.4.0. Two epics landed, three releases shipped, and the test count nearly tripled.

Epic 8: Render and Promote

Epic 8 delivered two distinct capabilities: turning compiled knowledge into Marp slide decks, and a promotion engine that gates which artifacts make it into the wiki.

Slide Deck Renderer

The renderer takes compiled knowledge and produces Marp-compatible markdown via Claude API. Marp is a solid choice here — it’s just markdown with slide separators, so the output is diffable, version-controllable, and doesn’t require a proprietary format.

Resizable Columns and WCAG Contrast Fixes on the Braves Dashboard

Tue, 07 Apr 2026 10:00:00 -0500

Light day. Two PRs merged on Braves Booth Intelligence, both polish work. No new features, no new endpoints. Just making the existing dashboard better for the people who actually use it during live broadcasts.

Resizable Columns with a Batter-First Layout

The dashboard has two main columns: batter stats on the left, pitcher stats on the right. The original layout gave the pitcher card the flex space. That was backwards. During a broadcast, the batter is the primary focus — who’s at the plate drives the conversation.

Knowledge OS Bootstrap: Seven Epics, Marketplace Security, and Production AI Fixes

Mon, 06 Apr 2026 10:00:00 -0500

Seven epics in one repo. Six releases in one day. A TypeScript monorepo that didn’t exist 48 hours ago now has a compiler pipeline, FTS5 search, and citation-verified answers. April 6th was the day intentional-cognition-os went from design documents to a working knowledge operating system.

What intentional-cognition-os Is

A local-first knowledge OS. You feed it raw corpus — PDFs, markdown, web clips. It compiles that into semantic knowledge. You ask questions. It answers with inline citations that trace back to source material through provenance chains.

Legal Toolkit, Epic Planning, and a Canary That Stopped Singing

Sun, 05 Apr 2026 10:00:00 -0500

Three projects. Eleven commits. Every one of them is about the same thing: building systems that check their own work.

A legal toolkit that audits contracts against seven compliance frameworks. An execution plan reviewed by six specialized auditors before a single line of code ships. A canary CI pipeline that was supposed to catch failures but had been silently dead for three days. April 5th was a day about verification — and what happens when you skip it.

Braves Booth v1.0.0: Player Drill-Down, Lineup Cache Bug, and Shipping 1.0

Sat, 04 Apr 2026 10:00:00 -0500

Braves Booth Intelligence is a real-time broadcast operations tool for Atlanta Braves radio. It pulls live game data from MLB’s GUMBO API, runs it through narrative generation, and surfaces radio-ready intel — matchup histories, milestone watches, pitching trends, bio nuggets — on a dashboard the broadcast team uses during games.

Today was v1.0.0 release day. Six commits. Twenty-seven files changed. One bug found during live testing that would have silently broken the app five minutes into every game.

Braves Booth — Idle Recap, Dashboard Density, and AI Pitcher Narratives

Fri, 03 Apr 2026 10:00:00 -0500

Between games, the Braves Booth dashboard used to show a tab bar with RECAP and PREVIEW buttons. Pick one. The problem: announcers don’t want to choose. They want the full picture — what just happened and what’s coming next — on a single screen with no clicks.

Two commits, 29 files, 600 lines changed. The idle view got rebuilt, the entire UI got tighter, and the AI pitcher narrative system got replaced with something that actually works.

Software Supply Chain Security After Axios

Thu, 02 Apr 2026 08:00:00 -0500

On March 31, 2026, attackers published two malicious versions of axios — a package with roughly 100 million weekly npm downloads — during a window of a little over three hours. Google Threat Intelligence Group attributed the campaign to UNC1069, a North Korea-nexus threat actor. The malicious releases introduced a dependency that used a postinstall script to deploy a cross-platform remote access trojan.

During that window, any CI/CD pipeline or developer workstation that freshly resolved the affected versions and allowed lifecycle scripts to run could have been compromised. Projects with previously committed lockfiles were far less likely to be affected.

IntentCAD v0.12.0: The Approval Toggle That Wasn't

Wed, 01 Apr 2026 10:00:00 -0500

You reject an operation. You realize you shouldn’t have. You click to approve it. Nothing happens.

That was the bug. IntentCAD’s operation approval UI allowed toggling approved operations to rejected but not the reverse. Once rejected, always rejected. The state transition was one-way when it should have been bidirectional.

This isn’t a dramatic production outage. It’s the kind of bug that sits in a codebase for weeks because nobody exercises that specific workflow until someone does, and then it’s a support ticket that takes 30 seconds to diagnose and 5 minutes to fix. The interesting part isn’t the fix — it’s why the bug existed in the first place.

March 2026: 35 Posts, the Eval Framework That Shipped 10 Epics in a Day, and a Meta-Milestone

Tue, 31 Mar 2026 18:00:00 -0500

March was the month the machinery became self-aware. Not in a dramatic AI sense — in the sense that the content system started tracking itself. The tier classification system was designed, built, and deployed. The blog-backfill pipeline went operational. And the j-rig binary eval framework proved that a well-structured evaluation system can move at sprint speed: ten epics from planning to production in a single day.

Thirty-five posts. Three hundred forty commits. The commit count dropped again — January had 627, February had 446, March has 340 — and that trend is now clearly a signal, not noise. The work is getting more focused. Fewer repositories are active. Each commit carries more weight. And the blog is capturing more of the work, which means the commits-per-post ratio continues to compress.

j-rig Binary Eval Framework: Ten Epics, One Day

Sun, 29 Mar 2026 10:00:00 -0500

Twenty-eight commits. Ten epics. A TypeScript monorepo that went from pnpm init to drift detection, eval packs, and a calibration engine in one calendar day. j-rig is a binary evaluation framework: given a skill definition and an execution trace, did the agent demonstrate the skill or not? Yes/no. Binary.

The “binary” part is the whole point. Eval frameworks love to produce scores — 0.73 out of 1.0, 4 out of 5 stars, “mostly correct.” These numbers feel precise but they’re not actionable. When your agent scores 0.73 on “can it parse a config file,” what do you do? Is that good? Is that a regression? Binary evaluation strips away the false precision. The agent either parsed the config file or it didn’t. Pass or fail. Now you can count, trend, and alert on real signals.

IntentCAD Viewer — Closing the DWG FastView Gap

Sat, 28 Mar 2026 10:00:00 -0600

DWG FastView is the benchmark. It’s the viewer AEC professionals already use. It loads fast, zooms smooth, and never locks the UI on a 50MB drawing. If your browser-based CAD viewer doesn’t match that bar, nobody will trust it with real work.

IntentCAD’s viewer wasn’t there yet. It worked. But “works” and “feels right” are different categories. The drawing would freeze for a few seconds on load. Zoom was instant — which sounds good until you realize instant zoom with no interpolation is disorienting. And when you selected three entities, they all turned the same shade of blue. Good luck telling them apart.

Deep Dive Part 4: Z3 Formal Verification, the Three-Layer Stack, and Claude Code as Architect

Fri, 27 Mar 2026 16:00:00 -0500

Every AI governance product running today uses some version of LLM-as-a-judge: feed the agent’s output to a second model and ask it whether the first model behaved. It is probabilistic reasoning about probabilistic reasoning. The result is a confidence score, not a proof. The IRSB ecosystem took a different path — formal verification using Z3, an SMT solver from Microsoft Research, which can mathematically prove the absence of a constraint violation rather than estimate its likelihood. That distinction matters when an autonomous agent has wallet access and real-world consequences attached to its decisions.

Deep Dive Part 3: A 12-Package Nested Monorepo That Watches AI Agents for You

Fri, 27 Mar 2026 15:00:00 -0500

Posting an on-chain receipt for a completed AI agent job is not the same as monitoring the receipt. Receipts are inert data. They do not check themselves for hash mismatches, verify that artifact files actually exist, or notice when an agent’s behavioral profile starts drifting toward anomalous territory. They certainly do not file a dispute within the 1-hour challenge window when something looks wrong.

That gap – between “we have on-chain evidence” and “we are actively verifying it and acting on it” – is exactly the space the IRSB Watchtower occupies. It is a fully autonomous monitoring system that watches agent activity, verifies evidence integrity, derives behavioral signals, computes risk scores, and triggers disputes without human intervention. At v0.5.0 it has approximately 500 tests covering its deterministic logic. The chain integration uses mock data while real IRSB client wiring is completed, but all the monitoring logic itself is production-grade.

Deep Dive Part 2: Cryptographic Receipts and the Evidence Pipeline That Proves What AI Agents Actually Did

Fri, 27 Mar 2026 14:00:00 -0500

“Trust me, the AI did good work.” That is the state of most AI agent frameworks today. The agent completes a task, your logs say it finished, and you are left reconstructing what actually happened from console output and hope. There is no cryptographic commitment. There is no unforgeable record. There is nothing to challenge.

The IRSB Ecosystem is built on the premise that claimed work and proved work are not the same thing. The evidence pipeline is the mechanism that closes that gap. It does not ask you to trust the solver. It asks you to verify the hash.

Deep Dive Part 1: Five On-Chain Enforcers That Make AI Agent Wallets Structurally Safe

Fri, 27 Mar 2026 13:00:00 -0500

Every framework that lets an AI agent control a wallet eventually faces the same uncomfortable question: what stops it from doing something you did not intend? Current answers range from “we wrote a policy document” to “we trust the model.” Neither is an answer an engineer should accept when real money is involved. The field has been shipping capability without shipping safety infrastructure, and the gap is widening.

The IRSB Ecosystem is a protocol-level attempt to close that gap — not by adding more agent memory or better prompting, but by encoding limits in Solidity and putting them on-chain before a transaction ever executes.

Deep Dive Part 4: Building 10 Production Gems with Claude Code as Tech Lead

Thu, 26 Mar 2026 16:00:00 -0500

Jeremy Longshore set out to build a family of production-grade Ruby gems that would form a governed operational intelligence layer for AI agents. That ecosystem is now complete: 10 repositories, 2,924 tests, zero RuboCop offenses, 60+ canonical documents, all v1 implementations shipped.

This article is about how that was built, and what a collaboration between a human architect and AI as tech lead actually looks like.

This is Part 4 of the Wild Ecosystem Deep Dive series.

Deep Dive Part 3: The Observability Loop — Teaching AI Tools to Improve Themselves

Thu, 26 Mar 2026 15:00:00 -0500

Most AI tool ecosystems follow a pattern: build the tools, ship them, hope they work. Updates happen when someone reports a problem or a human reviewer notices something is broken.

For AI agents operating with tool access in production Rails systems, with real stakes and real blast radius, hoping is not a strategy.

The wild ecosystem was built with a different assumption: agents operating with access need external feedback about what they struggle with. Not logging for compliance. Not metrics for observability dashboards. But structured signals about denial rates, failure patterns, latency outliers, and capability gaps.

Deep Dive Part 2: CLAUDE.md — The Missing Manual for Human-AI Software Collaboration

Thu, 26 Mar 2026 14:00:00 -0500

When you work with an AI coding assistant over multiple sessions, something breaks down around the third task. The assistant remembers the current file, but forgets why you decided not to use that library. It recalls the mission statement, but reinvents the directory structure. It knows what you built in session one, but doesn’t know what you explicitly decided NOT to build.

This is not a context window problem. It’s a contract problem.

Deep Dive Part 1: The Safety Architecture of Letting AI Agents Touch Your Production Rails Database

Thu, 26 Mar 2026 13:00:00 -0500

When an AI agent needs to debug a production issue, it faces a dilemma: either it has no access to live data (useless), or it gets a Rails console (dangerous). There is no safe middle ground in standard tooling.

The wild ecosystem solves this with a systematic approach to safe production introspection and gated mutations. This is not about trusting the AI. It is about building infrastructure that makes it impossible to cause damage, regardless of what code the agent executes or parameters it provides.

Write Once, Publish Everywhere: Building Content Distribution Across Three Sites

Wed, 25 Mar 2026 10:00:00 -0600

Three websites. One hundred blog posts. Thirty-one field notes. Four plugin repos. All synced automatically. None of it existed yesterday.

March 25th was about content distribution infrastructure. Not writing content — moving it. The problem: Intent Solutions runs three public-facing sites (startaitools.com, tonsofskills.com, intentsolutions.io) plus a plugin marketplace. Each site had its own content silo. Posts written here never appeared there. Plugin updates in source repos required manual marketplace syncs. The content existed. The distribution didn’t.

Usable, Not Just Functional: Entity Selection, Binary Eval, and 6 UX Fixes Across 4 Repos

Tue, 24 Mar 2026 10:00:00 -0600

Functional is table stakes. Usable is the moat.

March 24th was a 40+ commit day spread across four repositories. The theme wasn’t new capabilities. It was making existing capabilities pleasant to operate. Entity selection that highlights the right rectangle instead of a wrong one. Confirmation feedback after every review command. Color-coded tags that match their overlay boxes. The kind of work that separates a prototype from a tool someone uses twice.

X Bug Triage Plugin: Zero to v0.4.3 in One Day

Mon, 23 Mar 2026 10:00:00 -0600

Thirteen releases. Ten epics. Eighty-nine tests. Four extracted sub-agent skills. One day.

The x-bug-triage-plugin didn’t exist at midnight. By end of day it was at v0.4.3 with a full MCP tool surface, SQLite persistence, PII redaction, family-first bug clustering, and four standalone agent skills extracted from the monolith. Forty-plus commits across three repos. Here’s how a plugin goes from git init to production-shaped in a single session.

The Problem It Solves

Users report bugs on X/Twitter. Those reports are unstructured, often emotional, sometimes duplicates, and always missing context. The traditional workflow: scroll mentions, copy tweets into a spreadsheet, deduplicate manually, assign owners, create GitHub issues. Slow, lossy, and nobody wants the job.

Ninety Skills, Three Packs, One Day

Sun, 22 Mar 2026 10:00:00 -0600

One hundred commits. Three complete SaaS packs. Ninety skills from zero to shipped.

March 22nd was the day the pack factory proved it works. Not a prototype. Not a concept. Three production-ready integration packs — Sentry, Notion, and Supabase — each containing 30 skills, all built and scored in a single session.

The claude-code-plugins marketplace gained 90 new skills in a day. Meanwhile, cad-dxf-agent quietly shipped v0.11.0 with a CI gate that detects when your architecture drifts from your design documents.

Nuclear Option Day: Validator Rewrite, 63 New Packs, 414 Plugins

Sat, 21 Mar 2026 10:00:00 -0600

Some days you file tickets. Some days you refactor a module. March 21st was not one of those days.

Forty commits across claude-code-plugins. A complete validator rewrite. 63 new SaaS packs generated. Gold standard documentation across every Jeremy plugin. A compliance pipeline that ran until zero D/F grades remained. The marketplace went from ~350 plugins to 414.

This was the nuclear option. Rip out the old validator, replace it with one built to Anthropic’s 2026 spec, then score every single skill against it. Fix everything that fails. Ship it.

58 E2E Tests, a Slack Channel Launch, and the Auth Injection That Made It Work

Fri, 20 Mar 2026 10:00:00 -0600

You cannot run production E2E tests if you cannot log in. That sentence sounds obvious. It took sixteen commits to solve.

March 20th was a 25-commit day across three projects. The headline: cad-dxf-agent got a full production E2E test suite — 58 tests covering every user action — and a brand new project launched from empty directory to v0.1.0 with CI, tests, and upstream plugin submission. Plus the usual dependency bumps and a bug fix in the plugins marketplace.

Governed Knowledge: Two Major Releases, a Freshness Daemon, and Export Gating

Thu, 19 Mar 2026 10:00:00 -0600

Yesterday we built the knowledge base from zero to API. Today we shipped it twice.

qmd-team-intent-kb went from v0.1.0 to v0.3.0 in a single day. Eighteen commits. Two tagged releases. The first release (v0.2.0) was dependency hygiene — upgrading everything before the real work. The second (v0.3.0) was the real release: freshness-aware search, an edge daemon for automatic stale-memory deprecation, security hardening, content classification, and export gating.

Twenty commits across two repos. Here’s what actually shipped and why it matters.

Knowledge Base from Zero to API: Lifecycle State Machines and Policy Engines

Wed, 18 Mar 2026 10:00:00 -0600

Most knowledge bases are wikis with a search box. Articles go in, articles rot, nobody notices. The problem isn’t storage. It’s governance.

Articles have lifecycles. A draft isn’t ready for the team. A published article that hasn’t been reviewed in six months is a liability. An archived article should still be findable but clearly marked stale. If your knowledge base doesn’t model these states explicitly, you’re building a graveyard with good intentions.

Content Quality War: 7-Check Audit Across 340 Plugins

Tue, 17 Mar 2026 10:00:00 -0600

Every plugin had content. Most of it was junk.

Not missing. Not absent. Present but worthless. Boilerplate openings copy-pasted across 58 skills. Reference files that said TODO: add examples. Methodology guides that were empty markdown headers with no prose underneath. The files existed. The content didn’t.

Last week’s quality blitz replaced 130 stub files and crushed 4300 validator warnings. That fixed the obvious gaps. This week I went after the subtle ones — the files that passed every existing check because they weren’t empty, they were just bad.

Meta-Agent Orchestration and the UX of Removing Features

Mon, 16 Mar 2026 10:00:00 -0600

Nine specialist agents. One meta-agent to rule them.

The oss-agent-lab has been building toward this since Epoch 1. Nine focused agents — each handling a single concern like license scanning, dependency auditing, or README generation — working independently. Useful, but limited. A user had to know which agent to invoke, in what order, with what parameters.

The meta-agent eliminates that problem. It reads the capability manifests of all nine specialists, interprets what the user actually wants, and orchestrates multi-step workflows across them.

Building a Meta-Agent System From Scratch in One Day

Sun, 15 Mar 2026 10:00:00 -0600

What if the agent routing your requests was itself an agent? Not a switch statement with an LLM wrapper. An actual agent that evaluates other agents, scores their capabilities, remembers what worked, and routes based on evidence.

That’s what oss-agent-lab shipped in a single day. Six phases. Nine specialists. A meta-agent that orchestrates the entire team. Here’s how it came together.

Phase 1: Specs Before Code

Nine specification documents before a single line of application code. Base package structure, contracts, CLI skeleton, specialist template.

Terminal-Bold Redesign and the 0% Recall Bug

Sat, 14 Mar 2026 10:00:00 -0600

Yesterday was OKLCH. Today is what you do with it.

Phase 2 of the marketplace facelift landed with a “Terminal-Bold” aesthetic. Monospace headings. Sharper contrast ratios. More deliberate use of the OKLCH color tokens from Phase 1. The goal: make the marketplace feel like a tool built by developers, for developers.

The Terminal-Bold Aesthetic

The first facelift pass replaced the color system. This pass replaced the personality. Every page — homepage, explore, blog, skill details — got the same treatment:

OKLCH: Why Your CSS Color System Is Lying to You

Fri, 13 Mar 2026 10:00:00 -0600

Pick two colors in HSL. Same saturation, same lightness, different hues. They should look equally bright. They don’t.

This is the core lie of HSL. And it bit me during a full visual facelift of the claude-code-plugins marketplace.

The HSL Problem

Try this yourself. Open a browser console:

.yellow { background: hsl(60, 100%, 50%); }
.blue { background: hsl(240, 100%, 50%); }

Both are 100% saturation, 50% lightness. Mathematically identical brightness. Put them side by side and yellow screams while blue recedes. Your eyes aren’t broken — HSL is. It maps to a color model that doesn’t account for how human vision actually perceives luminance.

Design Tokens and Validator Parity: Marketplace Foundations

Thu, 12 Mar 2026 10:00:00 -0600

Five commits today. No new features. Just foundations.

The claude-code-plugins marketplace has over 900 plugins now. At that scale, inconsistency compounds. A hardcoded color here, a drifted validator there — small gaps that widen into real problems. Today was about closing two of them.

The Design Tokens Problem

The marketplace UI had grown organically. Every time I added a component, I’d pick a color value, a spacing value, a font size. Sometimes I’d match existing components by eyeballing the hex code. Sometimes I wouldn’t.

Mobile Fixes, Crypto Upgrades, and Killer Skills

Wed, 11 Mar 2026 10:00:00 -0600

Your marketplace looks great on a 1440px monitor. Nobody uses a 1440px monitor.

March 11th was a lighter day — five commits instead of the usual fifteen. But lighter doesn’t mean shallow. A mobile UX bug that had been annoying me for a week finally got fixed. Every crypto skill in the marketplace passed quality review. And a new homepage section started turning the marketplace into something people actually want to come back to.

Marketplace Quality Blitz: 130 Stub Files, 4300 Warnings, Zero Excuses

Tue, 10 Mar 2026 10:00:00 -0600

130 plugins had SKILL.md files that said nothing.

Not bad documentation. Not incomplete documentation. Template stubs. Copy-pasted boilerplate with placeholder text where the actual content should be. A user opening one of these files learned exactly two things: that the file existed and that nobody had bothered to fill it in.

This week I replaced all 130 of them.

The Stub Problem

When you scaffold a plugin, the generator creates a SKILL.md. That’s good practice. But when you scaffold 340 plugins over several months, some of those files never graduate from template to documentation. They sit there with [Describe your skill here] blocks, passing existence checks while providing zero value.

Verified Plugins Program: Building a Quality Signal for the Marketplace

Mon, 09 Mar 2026 10:00:00 -0600

A plugin marketplace without quality signals is a junk drawer.

You can have 900 plugins. You can have keyword filtering, install buttons, and a blog. But if a user can’t tell the difference between a polished tool and something someone pushed once and abandoned, your marketplace is noise. This week I built the system that fixes that.

The Problem with Plugin Discovery

The claude-code-plugins marketplace had grown fast. Hundreds of plugins across agents, hooks, slash commands, and MCP servers. The explore page worked. Keyword filtering landed in PR #321. Install counts were visible.

IntentCAD v0.8.0 — Thirteen EPICs, One Day

Sun, 08 Mar 2026 10:00:00 -0600

Thirteen EPICs. One day. The largest single-day feature push in IntentCAD history, from EPIC-CAD-19 to EPIC-CAD-30.

This isn’t a brag post. It’s a process post. Thirteen features shipped because of how they were scoped, not because anyone typed faster. The total diff is large but any individual PR is reviewable in 15 minutes. That’s the whole trick.

The EPIC Convention

Every major feature gets a named EPIC: EPIC-CAD-XX. Each EPIC is a vertical slice — its own PR, its own tests, its own migration path. No EPIC depends on another EPIC landing first. They can merge in any order.

Two Releases, One Day: IntentCAD v0.6.0 and v0.7.0

Sat, 07 Mar 2026 10:00:00 -0600

You don’t ship two releases in one day by working twice as fast. You ship them because the architecture lets you.

March 7th: 22 commits, 2 version bumps, 5 completed EPICs, and a fundamental shift in what IntentCAD actually is. Here’s how it happened and why the architecture made it possible.

Why Two Releases

v0.6.0 was infrastructure. Session durability, workflow packs, evaluation harness, architecture review. The kind of work that doesn’t change what users see — it changes what the system can handle.

From Tool to Platform: IntentCAD Ships Five EPICs in One Day

Fri, 06 Mar 2026 10:00:00 -0600

The DXF comparison tool is dead. Long live IntentCAD.

What started as cad-dxf-agent — a deterministic comparison engine for engineering drawings — grew past its name. It’s not just comparing files anymore. It’s interpreting markup, answering questions about drawing regions, detecting repeated conditions, and managing multi-user sessions with Google auth. Calling it “cad-dxf-agent” was underselling it by a factor of five.

So it’s IntentCAD now. And the rebrand wasn’t cosmetic. It came with five EPICs landing in a single day across PRs #73–#82.

PDF Extraction Bugs, Broadcast Persistence, and a 42-Commit Sweep Day

Thu, 05 Mar 2026 10:00:00 -0600

Forty-two commits across six repos in one day. No new features. Just closing loops, killing bugs, and hardening things that almost worked.

The most interesting work was in PDF extraction. The rest was necessary. Here’s the breakdown.

PDF Entities Are Not DXF Entities

The comparison engine in cad-dxf-agent works great on native DXF files. Geometry normalization, spatial binning, quantized fingerprints — all tuned for how DXF stores entities.

The problem: users also upload PDFs of engineering drawings. Scanned shop drawings, exported revision sets, vendor submittals as PDF.

SSE on Cloud Run: Every Platform Lie You Hit in Production

Wed, 04 Mar 2026 10:00:00 -0600

Server-Sent Events are the simplest real-time protocol on the web. One HTTP connection. Text frames. No WebSocket handshake. Every tutorial makes it look trivial.

Then you deploy to Cloud Run behind Firebase Hosting and spend nine PRs discovering that every platform between your code and the browser has opinions about HTTP responses — and SSE violates most of them.

This is the story of building real-time game updates for a Braves broadcast dashboard. Each fix revealed the next layer of broken assumptions.

Three Projects, Two Reverts, One Day

Tue, 03 Mar 2026 10:00:00 -0600

Nothing teaches you Firebase Hosting like renaming your domain three times before lunch.

March 3rd was a heavy day. Three projects, dozens of commits, and a domain migration that went sideways twice before landing. Here’s the unfiltered timeline.

The Domain Migration Saga

The claude-code-plugins marketplace needed a new home. claudecodeplugins.io was fine for a developer tool, but tonsofskills.com was the brand direction. Simple domain swap. Should take 20 minutes.

It took six commits and two reverts.

Live Data Backbone: Cache Layers, Circuit Breakers, and SSE for Broadcast

Mon, 02 Mar 2026 10:00:00 -0600

Yesterday was the scaffold. Today the data actually flows.

The Braves Booth Intelligence dashboard is worthless without live data. And live data during a broadcast has exactly one rule: never show an error screen. No spinners. No 500s. No “service unavailable.” The broadcast doesn’t pause while your API recovers.

That constraint shaped every design decision today. Ten commits, two merged PRs, and one architecture principle: every data source gets a cache layer, a circuit breaker, and a graceful degradation path.

Zero to CI: Full-Stack Dashboard in One Session

Sun, 01 Mar 2026 10:00:00 -0600

Empty directory at 8 AM. Green CI pipeline by dinner. 30 commits across two projects. Here’s how the day went.

The Project: Braves Booth Intelligence

The Atlanta Braves radio broadcast team needs real-time data during games. Statcast metrics, park factors, cohost context, narrative threads — all on a dark dashboard optimized for a broadcast booth where you glance, grab a number, and keep talking.

This isn’t a web app that happens to show baseball data. It’s a broadcast operations tool. That distinction drives every technical decision.

February 2026: 100% Tier 1 and the Security Audit That Changed Everything

Sat, 28 Feb 2026 18:00:00 -0600

February was an infrastructure month. No dramatic debugging sagas. No novel architectural breakthroughs that demanded long-form treatment. Just relentless execution across security auditing, event indexing, agent identity, and planner self-correction. The result: every classified post landed at Tier 1. That is not a failure of the classification system — it is an accurate reflection of what the work looked like.

When the work is “run the security audit, fix the findings, deploy the patch, verify the fix,” the honest classification is Field Note. Dressing it up as a Deep-Dive would be tier inflation, and the whole point of the system is to resist that temptation.

Engine to Product: Three Interfaces, One Codebase

Sat, 28 Feb 2026 10:00:00 -0600

You built the engine. Four layers of deterministic comparison, 1,875 tests, confidence scoring, alignment ladder. Great. Nobody can use it.

A library isn’t a product. The comparison engine in cad-dxf-agent could compare two DXF files with sub-thousandth precision — but only if you imported it in a Python script, instantiated the right classes, and knew the method signatures. That’s fine for me. It’s useless for the machinist reviewing revision changes.

This week was about wiring three interfaces onto one engine: a CLI for power users, a REST API for integrations, and a frontend wizard for everyone else. Four PRs, 76 new tests.

Golden Tests, Fuzz Testing, and a Nasty Fixture Taxonomy for DXF Revisions

Fri, 27 Feb 2026 10:00:00 -0600

Yesterday I shipped a deterministic DXF comparison engine — canonical models, alignment ladders, confidence scoring, the works. Four PRs, 814 tests, all green.

Today’s question: does it actually work on drawings that aren’t contrived?

The Problem with Unit Tests Alone

Unit tests prove individual functions behave correctly. They don’t prove the pipeline survives a revision where the drafter only updated the left half of the sheet, or where the master drawing is in inches and the revision is in millimeters.

Building a Deterministic DXF Comparison Engine in One Day

Thu, 26 Feb 2026 10:00:00 -0600

How do you compare two versions of an engineering drawing when one has been translated, rotated, or just has slightly different coordinate precision?

This is the core problem in cad-dxf-agent. The AI edit pipeline produces a modified DXF file, but you need to tell the user exactly what changed — which entities moved, which were added, which were deleted. And you need to do it deterministically, with confidence scores, even when floating-point noise makes coordinates drift by 0.0001 inches.

The Silent Killer in Your Web App: How Bare catch {} Blocks Hide Failures from Everyone

Wed, 25 Feb 2026 21:45:00 -0600

There’s a category of bug that I find genuinely maddening: the kind where the system works — no exceptions thrown, no 500 errors logged, CI is green — but the user never sees the output they’re supposed to see.

This is the story of exactly that bug in cad-dxf-agent, a local-first AI-powered DXF editor I’ve been building. After applying an AI-planned edit, users would see “Run an edit to see the result” — the placeholder. Forever. Even though the backend rendered the preview successfully.

CAD Agent v0.2.0: Planner Self-Correction, Hustle Auth Consolidation, and Moat Dual-Mode Gateway

Tue, 24 Feb 2026 10:00:00 -0600

Three projects, twelve commits, and the most interesting one is a feedback loop that teaches the planner to fix its own mistakes.

CAD Agent v0.2.0: Validation Feedback Loop

The CAD agent’s planner takes a natural language prompt and returns a structured changeset. The validator checks whether that changeset is safe to apply. In v0.1.0, a validation failure meant the user got an error message and had to rephrase their prompt.

CAD Agent Perf Audit and git-with-intent SPIFFE Identity Analysis

Mon, 23 Feb 2026 10:00:00 -0600

Not every day produces a release. February 23rd was two planning sessions across two projects — the kind of work that feels unproductive until you realize the next sprint runs 3x faster because of it.

CAD Agent: Performance Plan Audit

The cad-dxf-agent hit v0.1.0 a few days ago. It works. It’s also slow.

Loading a moderately complex DXF file (a structural floor plan with ~2,000 entities) takes 4-5 seconds on a decent machine. The edit engine processes changesets in under 100ms, but the initial parse and the viewer render are bottlenecks. For a desktop tool where Tony opens the same file 20 times a day, 5 seconds per open is noticeable. And that’s a 2,000-entity drawing. Real structural detail sheets with schedules, notes, and dimension chains can hit 15,000+ entities. At the current rate, those would take 30+ seconds to load. Unacceptable.

February 2026 State of Affairs: 255 Commits, 12 Projects, and What I Shipped

Sun, 22 Feb 2026 16:00:00 -0600

The Numbers

Between February 4 and February 22, 2026: 255+ commits across 12 projects. Zero blog posts. This is the catch-up.

Not every commit was a feature. Plenty were CI fixes, lint cleanup, documentation rewrites, and the kind of infrastructure work that doesn’t demo well but keeps everything running. But the output was real, and it shipped to production.

Project-by-Project

Moat — Policy-Enforced Execution for AI Agents

Moat went from a skeleton to a functioning execution layer with HTTP proxy domain allowlists, IRSB on-chain receipt integration, a 5-rule default-deny policy engine, and 117 integration tests. The CI saga — 6 commits to fix a pytest namespace package conflict in a Python monorepo — was a reminder that getting CI green after the code works locally is its own project.

Building Moat: Auth, On-Chain Receipts, and 117 Integration Tests in One Week

Sat, 21 Feb 2026 10:00:00 -0600

What Moat Does

Moat is a policy-enforced execution and trust layer for AI agents. When an autonomous agent wants to call an API, send a Slack message, or spend money, it goes through Moat. Every request gets evaluated against a policy engine, executed through a sandboxed adapter, and receipted — both off-chain in a database and on-chain on Sepolia.

Four FastAPI microservices make up the system: a Control Plane (capability registry), Gateway (execution choke-point), Trust Plane (reliability scoring), and an MCP Server (agent-facing tool surface).

CAD Agent Zero to v0.1.0, Intent Scout Economics, and Perception Auto-Ingestion

Fri, 20 Feb 2026 10:00:00 -0600

February 20th was a three-project day, but one project dominated. The cad-dxf-agent went from empty directory to tagged v0.1.0 release in 17 commits.

CAD Agent: The Full Greenfield

The idea is simple. A structural engineer types “move the column east by 2 feet” and the software edits the DXF file. Local-first, no cloud dependency for the core workflow, never modifies the original file.

Seventeen commits built the full pipeline:

DXF schema, parser, and writer. The schema defines the internal representation — entities, layers, blocks, attributes. The parser reads industry-standard DXF files into that schema. The writer serializes edited drawings back to valid DXF. Round-trip fidelity matters here. If you parse a DXF, make no changes, and write it back, the output should be byte-for-byte identical to the input. Any drift means the tool is silently corrupting drawings. The parser handles the main entity types a structural engineer encounters: LINE, LWPOLYLINE, CIRCLE, ARC, TEXT, MTEXT, INSERT (block references), and DIMENSION. Anything exotic gets preserved as raw DXF data — passed through without interpretation.

git-with-intent v0.9 to v0.10: Docker Upgrades, README Rewrites, and Strategic Research

Thu, 19 Feb 2026 10:00:00 -0600

Two Releases in a Week

git-with-intent shipped v0.9.0 on February 17 and v0.10.0 on February 19. Two days apart. The first release was a pre-GA security hardening pass. The second was a scale and operations maturity push. Together they closed the gap between “runs on my machine” and “can handle real tenants.”

v0.9.0: Pre-GA Security Hardening

The v0.9.0 release focused on making the platform secure enough to run multi-tenant workloads.

IRSB Security Audit: Pausable Patterns, Invariant Tests, and an Envio Indexer That Fought PostgreSQL

Wed, 18 Feb 2026 10:00:00 -0600

Security audits are unglamorous. You read every function, ask “what if this is called when it shouldn’t be,” and write tests for the answers. February 18th was 14 commits of that for the IRSB monorepo.

The Pausable Pattern on DisputeModule

The DisputeModule handles arbitration in the IRSB protocol. If a solver disputes a receipt, this contract manages the lifecycle: filing, evidence submission, resolution, and timeout-based auto-resolution.

The problem: there was no way to pause it. If a critical vulnerability surfaces in production, you need an emergency brake. Every other state-changing contract in IRSB had OpenZeppelin’s Pausable mixin. DisputeModule didn’t.

Session Cookie Auth, Forgot-Password Timeouts, and Killing Flaky E2E Tests

Tue, 17 Feb 2026 10:00:00 -0600

The Auth Stack Was Wrong

Hustle (hustlestats.io) is a youth soccer statistics platform built on Next.js 15 and Firebase. The auth system worked — until it didn’t. Users were getting logged out after one hour despite having a 14-day cookie. The forgot-password flow was timing out with 504 errors. And the Playwright E2E tests were failing randomly on every other run.

Three problems. Three different root causes. One painful week.

IRSB Monorepo v1.0.0: Extracting Shared Packages and Unifying a Blockchain Platform

Mon, 16 Feb 2026 14:00:00 -0600

Why a Monorepo

IRSB (Intent Receipts & Solver Bonds) is an on-chain guardrails system for AI agents. The protocol enforces spending limits, records execution receipts on-chain, and monitors agent behavior through a watchtower service. By February 2026, the project had grown to 37 Solidity contracts, a TypeScript solver, a watchtower with 12 internal packages, a Python agent service, and a new Envio HyperIndex indexer.

All of these lived in separate repositories. The solver imported types from the protocol SDK. The watchtower duplicated the same KMS signing logic. The indexer needed contract addresses from a shared constants file that existed in three different places.

Fixing Provider Registry Mutations and Sandbox Permissions in git-with-intent

Sun, 15 Feb 2026 10:00:00 -0600

The Bug: Global State Corruption

git-with-intent runs AI agents that interact with LLM providers. Each tenant registers their own custom providers — API keys, model configurations, cost metadata. The CustomProviderRegistry managed these registrations.

The problem: registering a custom provider for one tenant polluted the global registry for every other tenant.

// BEFORE: Modifies shared global state
register(config: CustomProviderConfig): void {
 const key = `${parsed.provider}:${parsed.model}`;
 this.customProviders.set(key, { config: parsed, registeredAt: Date.now() });

 // These two lines cause the bug:
 (PROVIDER_CAPABILITIES as Record<string, ProviderCapabilities>)[key] = capabilities;
 (PROVIDER_COSTS as Record<string, ProviderCostMetadata>)[key] = costMeta;
}

PROVIDER_CAPABILITIES and PROVIDER_COSTS are module-level constants — shared across the entire Node.js process. When tenant A registers a provider, tenant B sees it. When tenant A unregisters, tenant B loses it. When tests register providers, other tests inherit them.

Shipping a CAD Agent from Zero: DXF Parsing, Edit Engines, and LLM Planner Interfaces

Sat, 14 Feb 2026 10:00:00 -0600

The Problem

A structural engineer named Tony needs to edit CAD drawings. His workflow: open a DXF file, move some entities, update text labels, add block references, save to a new file. He does this hundreds of times. The edits are mechanical and repetitive.

The goal: let Tony type “move the column east by 2 feet” and have the software do it. Local-first, no cloud dependency for the core workflow, and never modify the original file.

git-with-intent Competitive Strategy and Perception Real Ingestion Pipeline

Fri, 13 Feb 2026 10:00:00 -0600

Two commits across two repos. A light day by commit count, but both commits landed meaningful capability that had been blocking next steps. git-with-intent got its competitive positioning documented — which unblocked the pricing page design and the README rewrite that followed later in the month. Perception closed the loop between the dashboard button and real article storage, which meant the product was finally demo-able without apologies about mock data.

git-with-intent Vitest 4 Migration Pain and IRSB Governance with 104 Moloch Tests

Thu, 12 Feb 2026 10:00:00 -0600

Eighteen commits across three repos. git-with-intent fought through a Vitest 4 migration that broke CI seven different ways. IRSB shipped v1.4.0 with governance contracts and a 104-test Moloch DAO suite. Perception got a dashboard fix.

git-with-intent: Vitest 4 Migration

The v0.8.0 prep for git-with-intent included upgrading from Vitest 3.x to Vitest 4. The test suite passed locally. CI failed. Then it failed six more times in six different ways.

Mock Pattern Changes

Vitest 4 changed how vi.mock() interacts with module resolution. In Vitest 3, mock declarations were hoisted above imports automatically. Vitest 4 introduced vi.hoisted() as an explicit mechanism and stopped auto-hoisting in several edge cases.

IRSB Multi-Release Prep and Hustle E2E Strict Mode Fixes

Wed, 11 Feb 2026 10:00:00 -0600

Eight commits across two repos. IRSB stacked up release prep for four versions. Hustle’s E2E suite got three targeted fixes for failures that had been intermittent long enough to become background noise.

IRSB Release Prep: Four Versions

Release prep is the unglamorous work between “code works” and “version ships.” Four IRSB packages needed version bumps: v0.3.0 for the solver, v0.5.0 for the watchtower, v1.0.1 for the SDK, and v1.3.1 for the protocol contracts.

Perception Dashboard: Wiring Real Triggers, Topic Watchlists, and the BSL-1.1 Decision

Tue, 10 Feb 2026 10:00:00 -0600

What Perception Does

Perception is a media intelligence dashboard. It ingests articles from 128 RSS feeds, scores them by relevance and trending signals, and surfaces the ones that matter through a React dashboard backed by Firestore and a FastAPI MCP service.

The dashboard existed before February. What didn’t exist: real data ingestion, interactive topic management, or auto-ingestion on login. The dashboard was running on mock data. This month, the plumbing got real.

IRSB Agent Guardrails Pivot, Products Workspace Launch, and the Pitch Deck Sprint

Mon, 09 Feb 2026 10:00:00 -0600

Thirteen commits across three repos. The biggest shift wasn’t code — it was strategic positioning. IRSB went from “intent receipts and solver bonds” to “on-chain guardrails for AI agents” in a single day.

The Guardrails Pivot

IRSB had been positioned as a general-purpose intent settlement protocol. The contracts worked. The tests passed. But the pitch was abstract — “receipts for solver execution” doesn’t make anyone’s eyes light up.

The pivot reframed everything around a concrete problem: AI agents with wallet access and no spending controls. Every major agent framework (AgentKit, ElizaOS, Olas, Virtuals) gives agents the ability to sign transactions. None of them answer the question: what happens when the agent overspends?

IRSB Four Releases in One Day, Perception Topic Watchlist, and Hustle Session Cookies

Sun, 08 Feb 2026 10:00:00 -0600

Three repos, seventeen commits. The IRSB monorepo pushed through four releases in a single day — clearing a backlog of fixes that had been accumulating across the solver, dashboard, SDK, and protocol packages. Perception moved from static topic display to interactive CRUD with real Firestore persistence. Hustle fixed the auth flow that had been silently expiring users after one hour and stabilized two more flaky E2E tests.

IRSB: v0.2.0 Through v1.2.0

Ten commits, four releases. The IRSB monorepo had accumulated fixes across multiple packages — TypeScript strict mode violations, ERC-8004 adapter badge rendering, and a Lit network key derivation bug that only surfaced on Sepolia. Instead of batching these into a single large release, I cut four separate versions to keep the changelog readable and bisectable.

IRSB On-Chain Solver Registration: Agent ID 967

Sat, 07 Feb 2026 10:00:00 -0600

A thin commit day by February standards — four commits across two repos. But one of those commits put an agent identity on-chain, which is worth writing up.

IRSB: Solver Registration on ERC-8004

Three commits. The first registered a solver identity on the ERC-8004 IdentityRegistry contract. The second added AI-CONTEXT cross-reference documentation. The third cleaned up the deployment scripts.

ERC-8004 IdentityRegistry

ERC-8004 is the identity standard for autonomous agents operating on-chain. The registry maps agent addresses to verifiable identity records: what the agent does, who operates it, what capabilities it claims, and what reputation it’s accumulated. Think of it as DNS for AI agents — a public, verifiable lookup from address to identity.

IRSB Agent Passkey Scaffold on Cloud Run and Perception v0.6.0 Trending

Fri, 06 Feb 2026 10:00:00 -0600

Two projects, twelve commits total, and each shipped something tangible. IRSB got its first agent authentication scaffold. Perception tagged a release. Neither project had more than six commits, but both moved from “in progress” to “deployed.”

IRSB: Agent Passkey on Cloud Run

Six commits building the agent-passkey service from scratch and deploying it to Cloud Run.

The Problem

IRSB’s agents need to authenticate against the protocol. Traditional API keys don’t work well for autonomous agents — keys get leaked in logs, rotated keys break running agents that cached the old key, and there’s no way to scope permissions per agent instance without building a custom authorization layer on top.

IRSB v0.1.0 Milestone, Perception YAML Feeds, and HN Expansion

Thu, 05 Feb 2026 10:00:00 -0600

Two projects dominated February 5th. IRSB hit its first tagged release. Perception expanded its feed coverage by 72%.

IRSB Monorepo: v0.1.0

Fourteen commits pushing the monorepo to its first milestone release. The version number is modest — v0.1.0, not v1.0.0 — because the protocol’s smart contracts haven’t been audited by a third party yet. But the infrastructure around the contracts is now release-quality.

Phase 3-7 AARs

After-Action Reviews for each completed development phase. These aren’t retrospective essays — they’re structured documents covering what was planned, what actually happened, what went wrong, and what changes to apply in the next phase.

Fixing Claude Code Hooks: The New Matcher Format

Wed, 04 Feb 2026 13:33:43 -0600

Claude Code recently changed their hooks format, and if you haven’t updated your project settings, you’ll see this cryptic error:

hooks: Expected array, but received undefined
Files with errors are skipped entirely, not just the invalid settings.

The Problem

The old hook format put command at the top level:

{
 "hooks": {
 "Stop": [
 {
 "matcher": "",
 "command": "bash .claude/hooks/my-script.sh"
 }
 ]
 }
}

This silently breaks - your entire settings file gets skipped.

GWI IDP Specification Suite, Bounties EV Scoring, and IRSB Resilience Patterns

Tue, 03 Feb 2026 10:00:00 -0600

Fifty-five commits across six repos. The highest single-day commit count of the month, though the commit count overstates the architectural significance. Most of these were specification documents, not code.

git-with-intent: The IDP Specification Sprint

Twenty-nine commits, and the bulk of them were specification documents for an Internal Developer Platform.

The IDP spec suite covers the standards a platform team needs to evaluate and enforce:

RAG pipeline specifications (chunking strategy, embedding model requirements, retrieval evaluation thresholds)
DORA metrics tracking (deployment frequency, lead time, change failure rate, MTTR)
SOC2 compliance requirements (access control logging, data retention policies, incident response)
SAST integration standards (which tools, which severity levels block merge, false positive handling)
Feature flag governance (TTL requirements, flag cleanup automation, percentage rollout gates)
Incident response procedures (severity classification, escalation paths, post-mortem templates)

Twenty-plus documents in total, each following the same template — purpose, scope, requirements, validation criteria, and integration points with git-with-intent’s analysis engine.

IRSB Prometheus Metrics, STCI CSV Upload, and Brand Refresh

Mon, 02 Feb 2026 10:00:00 -0600

Five repos touched, none of them deeply. February 2nd was a polish day — finishing things started earlier in the week and cleaning up loose ends across the portfolio. Sixteen commits total, none individually dramatic but collectively moving four projects forward.

IRSB Monorepo: Epic 1 Complete

Five commits closing out Epic 1. The headline is a shared Prometheus metrics package extracted from the monorepo’s services.

Each IRSB service was instrumenting its own metrics with slightly different label names, histogram buckets, and counter naming conventions. The inconsistencies were small but compounding:

IntentVision Phases 8-14 and Personal Brand Repositioning

Sun, 01 Feb 2026 10:00:00 -0600

February opened with an IntentVision sprint. Seven phases in a single day, pushing the product from a working dashboard toward something you could actually sell.

Twenty-eight commits across three repos. Nineteen on IntentVision, eight on jeremylongshore.com, and one on bounties. The IntentVision work was the main event. The jeremylongshore.com repositioning was strategic. The bounties commit was governance.

IntentVision: Phases 8 Through 14

The first seven phases (covered in a previous post) gave IntentVision its data layer, visualization primitives, and dashboard composition. Phases 8 through 14 are about operational maturity — the difference between a demo and a product.

January 2026: 32 Posts, 627 Commits, and the Month Everything Shipped

Sat, 31 Jan 2026 18:00:00 -0600

January was a demolition month. Thirty-two posts. Six hundred twenty-seven commits. Eight distinct projects with meaningful forward progress, three of them going from zero to shipped. December had higher raw commit volume (1,252), but December was mostly foundation-laying. January was the month things started arriving at production.

The difference between “building” and “shipping” is felt in the texture of the commits. December commits looked like init: scaffold project structure, chore: add CI config, feat: stub out module. January commits looked like feat: deploy SDK to npm, fix: production indexer race condition, release: v1.1.0. The work shifted from potential to delivered.

x402 Quickstart, GWI ARV Fixes, and the IntentVision DevOps Playbook

Sat, 31 Jan 2026 10:00:00 -0600

Twenty-two commits. Five repos. The kind of day where no single project gets a dramatic breakthrough but every project gets meaningfully better. IRSB led with thirteen commits of documentation and CI stabilization. git-with-intent got three targeted fixes. IntentVision got a real execution plan.

x402: The 30-Minute Quickstart

The x402 payment protocol shipped yesterday. Today it got a quickstart guide designed to take a developer from zero to a working payment flow in 30 minutes.

IRSB v1.1.0: CLI Verify, x402 Payment Protocol, and the SDK Rename

Fri, 30 Jan 2026 10:00:00 -0600

Nineteen commits across four repos. The biggest chunk — fifteen commits — went into IRSB itself, pushing through a CLI expansion, a payment protocol, a credibility standard, and a versioned release. The remaining four touched IntentVision, jeremylongshore.com, and PipelinePilot.

The irsb CLI and Receipt Verification

The CLI got a verify command. Until now, verifying an on-chain receipt meant calling the IntentReceiptHub contract directly — either through Etherscan or a custom script. The verify command wraps the contract read into a single invocation:

IRSB Security Audit Fixes, git-with-intent v0.6.0, and GitHub Profile Overhaul

Thu, 29 Jan 2026 10:00:00 -0600

Forty commits across five repos. The biggest day of January by commit count, and most of it was security work that made the IRSB protocol auditable.

IRSB Security Fixes (16 Commits)

Yesterday built the audit scaffold. Today started closing the findings.

HIGH Severity Fixes

SEC-001: Reentrancy in bounty settlement. The settleBounty function transferred tokens before updating the bounty status. Classic reentrancy vector — a malicious resolver contract could re-enter settleBounty during the token transfer callback and claim the bounty twice.

IRSB v1.0.0 Release Prep: Security Audit Scaffold and Mobile UX

Wed, 28 Jan 2026 10:00:00 -0600

Eleven commits, all in the IRSB monorepo. This was v1.0.0 release prep — the gap between “it works” and “it’s ready.”

README Rewrite

The old README was a developer’s scratchpad. Bullet points about what each package did, a quickstart that assumed you already knew the architecture, and a diagram made in ASCII that didn’t match the current package structure.

The rewrite targets three audiences in order: evaluators (what is this and why should I care), operators (how do I deploy and run it), and contributors (how do I develop against it). Each audience hits the section they need within 10 seconds of landing on the page.

IRSB Data Integrity Fixes and Portfolio Expansion

Tue, 27 Jan 2026 10:00:00 -0600

Eight commits across three repos. Most of the day was bug fixes in the IRSB monorepo — the kind of work that doesn’t produce features but produces trust. Every item on today’s list existed because the testnet deployment exposed gaps between what the code assumed and what the chain actually returned.

IRSB: Removing the Lies

Demo Data Purge

The IRSB dashboard had hardcoded demo data seeded for screenshots and investor demos. Fake operators, fake bounties, fake resolution events. The problem: some of that demo data leaked into the testnet deployment. A testnet user could see “Operator Alpha” with a fake track record and think it was real activity.

IRSB Public Site Redesign and git-with-intent v0.5.0 Release

Mon, 26 Jan 2026 10:00:00 -0600

Eighteen commits across four repos. The IRSB dashboard turned into a proper landing page, git-with-intent shipped its most important command yet, and the bounties platform stopped being unusable on phones.

IRSB: Dashboard to Landing Page

The old IRSB site was a dashboard. If you landed on it without context, you saw data grids and charts that meant nothing. The redesign flips the model: the public site is a landing page that explains what IRSB does, and the dashboard lives behind authentication.

IRSB Go-to-Market Sprint: Sepolia Deployment, TypeScript SDK, and Subgraph

Sun, 25 Jan 2026 10:00:00 -0600

The Go-to-Market Push

IRSB had been a protocol with working contracts and passing tests. What it didn’t have was the surrounding infrastructure that makes a protocol investable and usable by external developers. January 25th was the day that changed — 25 commits on IRSB alone across every layer of the go-to-market stack.

This wasn’t a technical exploration day. It was a business-driven sprint with a clear goal: produce the artifacts that a potential investor or integration partner would need to evaluate the protocol. That meant documentation (investor report + feasibility study), tooling (SDK + subgraph), deployment (Sepolia + dashboard), and credibility signals (security hardening + auditor outreach).

County Line Procedural Terrain, Bounty Memory Layer

Sat, 24 Jan 2026 10:00:00 -0600

Procedural Terrain

County Line’s static map was a placeholder. Handcrafted terrain works for small areas but mud racing needs variety — different trail layouts, varying elevation, terrain textures that change between runs. January 24th started the procedural generation system.

The terrain generation uses Roblox’s Terrain:FillBlock and Terrain:FillBall APIs to place voxel-based terrain at runtime. A seed-based noise function (Perlin via math.noise) controls elevation. The generator runs on the server at place load, creating a unique layout each session while keeping the structural features consistent — hills are always where you expect hills, but the exact contours vary.

County Line Visual Sprint, Bounty Orchestrator Greenfield, GWI v0.4.0

Fri, 23 Jan 2026 10:00:00 -0600

Fifty-Three Commits, Five Repos

January 23rd was a volume day. Not the kind of volume that comes from a deep debugging session — the kind that comes from parallel progress across projects that all need attention at the same time. Five repos, 53 commits, no single thread dominating.

The risk with volume days is that none of the work is deep enough to be interesting. Today walks that line. County Line’s visual sprint had real craft decisions. The bounty orchestrator is genuinely new architecture. The rest is maintenance.

County Line: Roblox Game from Template to Feature-Complete in One Day

Thu, 22 Jan 2026 10:00:00 -0600

From Template to Playable

County Line is a UTV mud racing game for Roblox. On January 22nd it went from a blank roblox-game-template initial commit to a feature-complete game across six development phases in 14 commits. Three repos were touched: the game itself, the template it was scaffolded from, and supporting agent infrastructure.

The velocity came from having a structured phase plan before writing any code. Each phase had clear exit criteria, and no phase started until the previous one was done. Six phases, one day, zero rework.

Drop: Two-Stage Onboarding with Mandatory Verification Gate

Wed, 21 Jan 2026 10:00:00 -0600

One Commit, One Decision

Some days produce fifty commits across five repos. January 21st produced one. A single commit in the Drop project adding a two-stage onboarding system with a mandatory verification gate between signup and full access.

The commit was small but the decision it encodes is not. Drop had been letting users straight through after signup — create account, land on dashboard, start using the product. The problem: unverified email addresses were accumulating in the user table, creating support burden when password resets failed because the address was a typo, and making any future email-based communication unreliable.

Landing Page Conversion Optimization and Legal Pages

Tue, 20 Jan 2026 10:00:00 -0600

Four commits across two repos. The work split between making the Intent Solutions landing page actually convert visitors and adding the legal foundation that a professional services company needs.

intent-solutions-landing: Projects Showcase

The landing page listed services but didn’t show work. The new projects showcase surfaces 17 active projects with consistent metadata:

Project name and one-line description
Tech stack badges (React, Firebase, Vertex AI, etc.)
Status indicator (active/maintained/archived)
Link to live demo or documentation

The showcase renders as a responsive grid – three columns on desktop, two on tablet, single column on mobile. Each card is intentionally minimal: name, description, stack, status. No screenshots, no long descriptions. The goal is density – a visitor should scan all 17 projects in under 30 seconds and find the ones relevant to their needs.

Post-Merge Cleanup, Landing Redesign, and Portfolio Theme Overhaul

Mon, 19 Jan 2026 10:00:00 -0600

Seven commits across four repos. A cleanup day – resolving merge debt from the previous week’s feature branches, filling content gaps on the landing site, and refreshing the personal site’s visual identity. None of these changes are individually significant, but collectively they close out a week of parallel development and get everything back to a clean main branch.

The pattern of building features in parallel and then spending a day on merge cleanup is becoming standard for multi-repo work. It’s not glamorous, but skipping the cleanup creates compounding confusion.

Firebase Migration Debugging Saga, GWI PR Reviews, and the Bounty Proof Wall

Sun, 18 Jan 2026 10:00:00 -0600

Thirty-six commits across three repos. The Firebase migration ate most of the day – not because the migration itself was hard, but because CI kept breaking in new and creative ways. The GWI and bounty work shipped cleanly by comparison.

Firebase Migration: The Plan

The intent-solutions-landing site was on Netlify. It worked fine, but having the company landing page on a different platform than everything else (Firebase) meant two sets of deployment configs, two DNS management interfaces, two SSL certificate renewal processes. Consolidation to Firebase Hosting was the goal.

Bounty Scoring Algorithm, GWI Compliance Reports, and Kilo Image Support

Sat, 17 Jan 2026 10:00:00 -0600

Eight commits across three repos. The bounty work was the biggest chunk – a scoring algorithm that needed to balance multiple competing signals. GWI compliance reports filled a gap in the audit story. Kilo image support was a feature request that took two commits.

Bounty Scoring Algorithm

The bounty tracker needed a way to rank available bounties. Not just by dollar value – a $5,000 bounty on an unfamiliar codebase in a language you don’t know isn’t worth more than a $500 bounty you can close in an hour.

Proposal Template Launch and IRSB CLAUDE.md Cleanup

Fri, 16 Jan 2026 10:00:00 -0600

Three commits across two repos. A light day by commit count, but both changes address real gaps that were causing friction in daily operations.

Proposal Template: Initial Release

The proposal-template repo shipped its first version. The template standardizes how Intent Solutions writes client proposals – consistent structure, consistent safety language, consistent pricing presentation. Before this, each proposal was a one-off Google Doc with whatever structure felt right at the time. Some had safety sections, some didn’t. Some quoted hourly, some quoted fixed-price. The inconsistency was starting to show.

Intent Catalog: Six Phases from Empty Repo to Production Control Plane

Thu, 15 Jan 2026 10:00:00 -0600

Sixteen commits, all in the intent-catalog repo. The project went from an empty directory to a production control plane in a single day, built through six deliberate phases.

Why a Catalog

Intent Solutions runs a dozen active repositories. Each has its own conventions, its own deployment pipeline, its own documentation style. The intent-catalog is the central registry that knows what exists, where it lives, how healthy it is, and what documentation covers it.

IRSB Protocol MVP, Vertex AI Embeddings, and GWI Violation Pipeline

Wed, 14 Jan 2026 10:00:00 -0600

Thirteen commits across three repos. The day split between three distinct workstreams: getting IRSB from bootstrap to an actual MVP, standing up the git-with-intent violation pipeline, and migrating Executive Intent’s embedding layer to Vertex AI.

IRSB: Zero to MVP

The IRSB monorepo got its first real functionality today. Previous work had set up the repo structure and contract scaffolding, but nothing ran end-to-end. Today changed that.

DisputeModule Timeout Resolution

The DisputeModule handles what happens when an AI agent exceeds a spending bond. The original design required manual intervention – a human reviews the dispute and releases or slashes the bond. That works for high-value disputes but creates an unbounded queue for small ones.

Executive Intent UI Polish and Bounty Tracker Airtable Sync

Tue, 13 Jan 2026 10:00:00 -0600

Light day after yesterday’s twenty-nine commit marathon. Six commits, two repos. The kind of focused polish work that’s easy to skip and hard to go back and do later.

The pattern with UI polish is that each individual fix seems trivial — change a color, fix an alignment, adjust a width. But the cumulative effect is the difference between “this looks like a prototype” and “this looks like a product.” Five small fixes can shift user perception more than one large feature.

Executive Intent Proof System and git-with-intent Audit Pipeline

Mon, 12 Jan 2026 10:00:00 -0600

Twenty-nine commits. The highest single-day count since the marketplace launch sprint in October. January 12th was about making systems provable — building the infrastructure to demonstrate that things work, not just assert that they do.

Two projects, one principle: if you can’t show your evidence chain, your conclusions are opinions. Executive Intent got a proof system that traces every recommendation back to data. git-with-intent got an audit log that traces every code change back to a declared intent.

Executive Intent MVP Scaffold, Drop Coaching Curriculum, and Bounty Tracker Buildout

Sun, 11 Jan 2026 10:00:00 -0600

Four repos, fifteen commits, three distinct workstreams. January 11th split between greenfield scaffolding, curriculum design, and feature buildout. The unifying theme is preparation — each workstream is setting up the conditions for fast iteration rather than iterating fast on shaky foundations.

Executive Intent MVP Scaffold

Executive Intent is a new platform for AI-assisted executive decision support. The premise: executives make decisions based on incomplete data scattered across a dozen tools. The platform aggregates evidence, surfaces relevant context, and presents recommendations with provenance chains so the decision-maker can trust the input.

Hustle E2E Stabilization Sprint and Bounty Tracker Init

Sat, 10 Jan 2026 10:00:00 -0600

Some days you ship features. Some days you make the tests stop lying to you. January 10th was the second kind.

Fifteen commits across three repos. Thirteen went into the Hustle E2E test suite. The tests weren’t failing — they were flaking. Passing on one run, failing on the next, with no code changes in between. The kind of instability that erodes trust in CI until everyone ignores it.

A flaky test suite is worse than no test suite. No tests means you know you’re flying blind. Flaky tests mean you think you have a safety net, but it has holes you can’t see. Every “retry and it’ll pass” is a small erosion of the habit of treating red CI as a real signal.

Drop Monorepo Restructure, /ship-shelly Reporting Skill, and Diagram Automation

Fri, 09 Jan 2026 10:00:00 -0600

Monorepos have a half-life. They start simple, grow organically, and eventually reach a point where the directory structure actively fights the development workflow. January 9th was the day the Drop monorepo hit that threshold.

Eight commits across two repos. The big one was the Drop restructure — moving from a flat src/ layout to a proper packages/ workspace. The smaller one was file cleanup on the Nixtla repo.

Packages Layout Migration

The Drop repo had been a flat structure — all source code in src/, all tests in tests/, shared utilities mixed in with domain logic. It worked when the repo had three modules. It stopped working at seven.

Infrastructure Maintenance: MCP Server Upgrade, npm Security Fixes, and a Portfolio Rebuild

Thu, 08 Jan 2026 10:00:00 -0600

Maintenance days are the ones nobody plans and everybody needs. January 8th was fourteen commits across four repos, and not one of them added a new feature. Every commit either fixed something broken, upgraded something outdated, or replaced something that had outgrown its original design.

The temptation is always to skip maintenance and build the next thing. But deferred maintenance is invisible debt. The MCP server falling behind means you miss a race condition fix. The npm audit warnings piling up means you stop reading them. The personal site being stale means it’s actively misrepresenting what you do.

Governance Day: Proprietary Licenses, Portfolio Refresh, and STCI Dashboard v0.5.0

Wed, 07 Jan 2026 10:00:00 -0600

Not every productive day involves writing application code. Some days the work is governance — the legal and organizational scaffolding that lets everything else move faster.

January 7th was four commits across four repos. All housekeeping. All overdue.

The kind of work that sits on a TODO list for weeks because there’s always a more interesting problem to solve. But governance debt compounds. A missing license today is a legal question tomorrow. A stale portfolio today is a missed opportunity next week.

Nixtla BSL License Pivot

Tue, 06 Jan 2026 10:00:00 -0600

Two commits. One governance decision. The thinnest day of the month so far.

Why BSL 1.1

Nixtla’s baseline lab has been MIT-licensed since inception. MIT is the default choice for developer tools — maximum adoption, zero friction, everyone can use it however they want.

The problem with MIT for a commercial product: competitors can take your code, wrap a paid service around it, and sell it back to the same market you’re trying to serve. You built it. They profit from it. Your only competitive advantage is moving faster, which is not a sustainable moat when someone with a bigger team can fork and iterate.

Intent Blueprint Docs Phases 2-5, Hustle E2E, and the Turbopack Body Bug

Mon, 05 Jan 2026 10:00:00 -0600

Thirty-six commits across six repos. The day split cleanly: documentation infrastructure in the morning, E2E debugging in the afternoon.

Intent Blueprint Docs: Four Phases, One Day

Intent Blueprint Docs went from Phase 1 scaffolding (laid down on the 4th) to Phase 5 enterprise features by end of day. That’s four phases of a documentation generation platform in a single session.

Phase 2: Interview Engine — The system now asks questions. Instead of generating docs from static templates, Phase 2 introduced a conversational interview flow. The engine asks about your architecture, your deployment model, your team structure, and generates documentation tailored to the answers. Think of it as a documentation wizard, except the wizard actually understands software systems.

Eleven-Repo Sprint: ADK Deployment Battle, STCI Redesign, and Scattered Fixes

Sun, 04 Jan 2026 10:00:00 -0600

Eighty-seven commits. Eleven repos. Most of them fixes.

January 4th was the kind of day where the commit count looks impressive and the actual progress is modest. High volume, scattered focus. Here’s the honest breakdown.

The Perception ADK Deployment Battle

Twenty-two commits on Perception. Almost all of them deployment fixes.

The Perception agent runs on Google’s ADK (Agent Development Kit) with Agent Engine as the hosting layer. Agent Engine is Google’s managed runtime for ADK agents — you deploy your agent definition and it handles scaling, versioning, and endpoint management.

Building External Plugin Sync: How We Keep 258 Community Plugins Fresh

Sat, 03 Jan 2026 02:50:00 -0600

The Problem: Static Forks Go Stale

We got a PR from Numman Ali adding two plugins to our Claude Code marketplace:

gastown: Multi-agent orchestrator for Claude Code
zai-cli: Vision, search, reader, and GitHub exploration

But then he commented:

“Hey, I’m constantly updating the plugin and this will become stale very quickly, I don’t think it’s a good idea to publish like this. You might want to add a sync mechanism like I’ve done for dev-browser by Sawyer Hood”

STCI Zero to v0.1.0: A Token Cost Index in One Day

Fri, 02 Jan 2026 10:00:00 -0600

Yesterday’s ADR said what STCI would be. Today it exists.

Eleven commits. One repo. Full pipeline from data collection to production API, released as v0.1.0 by end of day.

The Pipeline

STCI — the token cost index — tracks LLM API pricing across providers and models over time. The problem it solves: model pricing changes silently. OpenAI adjusts rates. Anthropic launches new tiers. Google reprices Gemini. If you’re running production workloads across multiple providers, you need a ledger of what things actually cost, not what the pricing page said last time you checked.

New Year's Day: Gastown Viewer, STCI Launch, and Four Repos Deep

Thu, 01 Jan 2026 10:00:00 -0600

Most people start the new year with resolutions. I started it with goreleaser configs and daemon HTTP APIs.

January 1st hit 26 commits across 4 repos. Not a typo. Here’s what shipped.

Gastown Viewer: Scaffold to MVP

Gastown Viewer went from an empty directory to a working product in a single day. The concept: a TUI and web interface for viewing and navigating structured intent data, backed by a daemon HTTP API.

December 2025: The Highest Gear — 1252 Commits and a Roblox Game

Wed, 31 Dec 2025 18:00:00 -0600

This month broke everything. 1252 commits — more than October and November combined, then doubled. The post count landed between the two previous months, but the quality distribution hit the highest T1 rate yet. And somehow there was time to build a Roblox game and ship a Go CLI on New Year’s Eve.

December answered November’s calibration question: yes, you can increase volume and keep quality high. You just have to be relentless about what earns a post.

New Year's Eve: A Go CLI From Scratch, a Security Fix, and Two Releases

Wed, 31 Dec 2025 10:00:00 -0600

Last day of 2025. Five projects touched. Twenty-five commits. One project built from nothing, one patched a security hole that should never have existed, and two shipped point releases to close out the year clean.

create-agent-skill: New Go CLI

Nine commits. Brand new project. A Go CLI tool for validating and scaffolding Claude Code agent skills. The problem it solves: skill definitions are YAML files with a specific schema, and getting the schema wrong means the skill silently fails to load or behaves unexpectedly at runtime.

Dream Gym Sprints, Email AI Stack, and 128 RSS Feeds

Mon, 29 Dec 2025 10:00:00 -0600

Four projects. Thirty-eight commits. Two of them are building real product features, one is growing into an intelligence platform, and one just needed a Dockerfile fix.

Dream Gym: Sprints 1 Through 3

Hustle’s Dream Gym module went from concept to working product in three sprints and fourteen commits.

Sprint 1: Workout Logging. The core data model is straightforward — exercises, sets, reps, weight, duration. But the UX question was whether to optimize for speed or detail. Speed won.

Building Post-Compaction Recovery for AI Agent Workflows with Beads

Sun, 28 Dec 2025 14:30:00 -0600

When Claude Code compacts (summarizes) conversations, you lose critical context about what you were working on. Here’s how I solved that problem with a git-based task persistence system - and the debugging journey that made it work.

The Problem: Context Loss After Compaction

Claude Code has unlimited context through automatic summarization. When your conversation gets long, it “compacts” by summarizing earlier parts. This is great for memory efficiency, but creates a critical problem:

GWI v0.3.0, Hustle CI Goes Green, and Intent Mail Gets an AI Brain

Sat, 27 Dec 2025 10:00:00 -0600

December 27th was a convergence day. Three projects that had been grinding through separate backlogs all hit release-worthy milestones at the same time. Thirty-eight commits across git-with-intent, Hustle, and Intent Mail.

git-with-intent v0.3.0

The v0.3.0 release closed four epics: F1 feature hardening, monitoring infrastructure, forecasting pipeline, and infra upgrades. Twenty-three commits landed across the board.

F1 feature hardening cleaned up rough edges that accumulated during the v0.2.x cycle. Approval gate edge cases — empty diff handling, multi-commit squash detection, and branch protection rule conflicts — all got explicit handling instead of falling through to a generic error path. The kind of polish that doesn’t show up in a changelog but prevents support tickets.

GWI RBAC Governance and Hustle CI Stabilization

Fri, 26 Dec 2025 10:00:00 -0600

December 26th. Three commits on git-with-intent, three on hustle. The GWI work was about governance. The hustle work was about not breaking things.

git-with-intent: RBAC and Governance

The RBAC system adds the multi-tenant access layer that git-with-intent needed before any real organization could use it. Three commits covering the full governance surface.

Tenant Management

Each tenant gets an isolated namespace with its own configuration, agent definitions, and run history.

Tenant creation provisions the namespace, sets default quotas, and generates an API key scoped to that tenant. Tenant deletion is soft — the namespace gets marked inactive, data is retained for the audit retention period, and the API key is revoked immediately.

Christmas Day: Dream Gym MVP and Intent Mail IMAP Connector

Thu, 25 Dec 2025 10:00:00 -0600

Yes, I committed code on Christmas. Eight commits on hustle, one on intent-mail.

Dream Gym MVP

The hustle repo got a new product: Dream Gym. A fitness tracking app aimed at the same youth sports market that HustleStats serves.

The MVP needed three things: user registration, authentication, and a landing page that explained what the product does.

Registration and Session Cookies

Registration was straightforward Firebase Auth with email/password. The interesting part was the session cookie implementation.

Christmas Eve Cleanup: GWI SDK Types and Intent Mail Audit Log

Wed, 24 Dec 2025 10:00:00 -0600

Christmas Eve. Six commits. The kind of day where you polish what shipped yesterday instead of building something new.

git-with-intent: SDK Types

Two commits on git-with-intent. The SDK types needed an update — TypeScript definitions for the client library had drifted from the actual API surface.

New endpoints added in v0.10.0 (budget, quota, provider health) didn’t have corresponding type definitions. Any TypeScript consumer of the SDK was either using any or maintaining their own type stubs.

Intent Mail: Full Email Platform in a Day — Gmail, Outlook, and a Rules Engine

Tue, 23 Dec 2025 10:00:00 -0600

35 commits in one repo. By the end of December 23rd, intent-mail was a working email platform with two provider connectors, full-text search, threaded send, attachment support, and a rules engine that could automate triage without touching the inbox until you said go.

The Storage Layer: SQLite + FTS5

Email data has two access patterns: exact lookup (give me this thread) and fuzzy search (find all emails about the deployment incident). SQLite handles the first pattern natively. FTS5 — SQLite’s full-text search extension — handles the second.

Local RAG NEXUS Upgrade and Nixtla Validation Infrastructure

Mon, 22 Dec 2025 10:00:00 -0600

December 22nd was a 35-commit day across four repos. The headline: local-rag-agent shipped a complete hybrid cloud architecture in 17 commits and a versioned release. Nixtla hardened its validation infrastructure. git-with-intent migrated its grading system to SQLite.

One of those days where every project moved forward.

NEXUS Hybrid Cloud Upgrade

The local-rag-agent had been locked to a single LLM provider since its inception. Anthropic’s Claude, hardcoded. That works for a personal tool. It doesn’t work when you want to run the same RAG pipeline against different providers for cost comparison, latency testing, or compliance reasons where certain data can’t leave a specific cloud tenant.

CEO Feedback Pivot and the Nixtla Skills Blitz

Sun, 21 Dec 2025 10:00:00 -0600

The fastest way to learn your messaging is wrong is to show it to the person writing the checks.

Lumera Pivots on Terminology

Five commits on Lumera-Emanuel, and the most important one deleted more than it added. The CEO looked at the product description and flagged the WOW terminology — “Wisdom of the World,” a framing I’d been using to describe the agent memory model.

His feedback was direct: it sounded like a marketing tagline, not a technical capability. Worse, it obscured the actual value proposition.

Lumera-Emanuel Launch and git-with-intent Open-Source Release

Sat, 20 Dec 2025 10:00:00 -0600

Two projects shipped on December 20th. One was brand new. The other opened its doors.

Lumera-Emanuel: Privacy-First Agent Memory

Lumera-Emanuel went from empty repo to working system in 11 commits. The goal: a privacy-first memory layer for AI agents that encrypts everything at rest and gives the agent structured recall without leaking user data to the host.

Encryption Layer

The core storage is SQLite with AES-256-GCM encryption. Every memory entry gets encrypted before it touches disk. The encryption key derives from a user-provided passphrase via PBKDF2 with a unique salt per entry. No plaintext ever persists.

Beads Rollout: 22 Repos, One Governance Pattern

Fri, 19 Dec 2025 10:00:00 -0600

Seventy-six commits. Twenty-two repos. One day. And most of it was the same two commits repeated eleven times.

December 19th was a governance rollout day. The beads task tracking system had been running in three repos for a week. It was time to deploy it everywhere.

The Beads Pattern

Beads (bd) is the post-compaction recovery system for AI-assisted development. When Claude Code compacts a long conversation, it loses context about what you were working on. Beads persists task state in git so you can recover after compaction.

Production Push: 70 Phases, Cloud Deploy, and the Docker Build Gauntlet

Thu, 18 Dec 2025 10:00:00 -0600

The previous three days built the product. December 18th was about making it run somewhere that isn’t my laptop.

Thirty-two commits spanning phases 32 through 70. The work falls into three buckets: infrastructure-as-code, cloud deployment, and the surprisingly painful process of getting Docker builds to actually work.

OpenTofu Migration

git-with-intent’s infrastructure was defined in Terraform. On December 18th it moved to OpenTofu.

The migration itself was uneventful. OpenTofu is a fork of Terraform with compatible syntax. Replace terraform with tofu in your commands, update the CI workflow, done. The state file format is identical. No resource recreation needed.

Feature Marathon: git-with-intent Phases 9 Through 30

Wed, 17 Dec 2025 10:00:00 -0600

Thirty-eight commits. Twenty-two phases. One day. This is what feature velocity looks like when the architecture is right and you’re not fighting your own abstractions.

December 17th was a marathon day for git-with-intent. The connector framework from the previous day gave me a stable foundation. Now it was time to build everything that sits on top of it.

The Phase Map

Here’s what shipped, grouped by capability:

Remote Registry (Phases 9-10)

The connector registry from phase 4 was local — connectors registered at startup and lived in memory. Phases 9-10 moved the registry to a remote service with API endpoints for registration, discovery, and health monitoring.

Architecture Reboot: git-with-intent Connector Framework and GA Hardening

Tue, 16 Dec 2025 10:00:00 -0600

One day after bootstrapping git-with-intent to v0.2.0, I threw most of it away.

Not literally. The core intent classification engine survived. But the architecture around it — the CLI structure, the plugin system, the way connectors talked to the core — all of it got rebooted. Forty-one commits in a single day, and the result was a product that looked nothing like what shipped 24 hours earlier.

Why Reboot After One Day

The v0.2.0 architecture had a fundamental problem: every integration was hardcoded. Want to analyze GitHub PRs? Write a GitHub module. Want to analyze GitLab MRs? Write a GitLab module. Want to read from Bitbucket? Another module. Each one duplicated the same patterns — authentication, pagination, rate limiting, error handling — with slight variations.

Two Products Bootstrapped from Zero to Release in One Day

Mon, 15 Dec 2025 10:00:00 -0600

December 15th was a bootstrapping day. Two products went from empty directories to tagged releases. Not prototypes. Not “hello world” scaffolds. Actual versioned releases with real functionality.

git-with-intent: 11 Commits Through 7 Phases

git-with-intent is the AI-assisted git workflow tool. On December 15th it went from concept to v0.2.0 across 11 commits.

The phases tell the story:

Phase 1: Core commit analysis engine. Parse git history, extract semantic meaning from diffs.
Phase 2: Intent classification. Map commits to intent categories (feature, fix, refactor, chore).
Phase 3: Workflow templates. Predefined patterns for common git workflows.
Phase 4: CLI scaffolding. Commander.js setup with subcommands for each operation.
Phase 5: Configuration system. User-level and repo-level config with sensible defaults.
Phase 6: Output formatting. Structured output for terminal, JSON, and markdown.
Phase 7: Release prep. Version bump, changelog generation, LICENSE, README.

Each phase was a focused commit or two. No phase depended on a phase that hadn’t been built yet. The ordering was deliberate — you can’t build intent classification without a commit analysis engine, and you can’t build a CLI without knowing what operations you’re exposing.

Building a Complete React Native Mobile App in One Session: 17,620 Lines of Production Code

Sat, 13 Dec 2025 00:00:00 +0000

The Challenge

Transform a Next.js web application into a native mobile app ready for iOS App Store and Google Play Store submission. Not a prototype. Not an MVP. A complete, production-ready application with full feature parity.

Time constraint: One working session.

Result: 17,620 lines of code, 37 files, 10 screens, full CI/CD pipeline.

The Stack

Layer	Technology	Why
Framework	Expo SDK 54	Managed workflow, OTA updates, EAS Build
Navigation	Expo Router	File-based routing (familiar from Next.js)
Language	TypeScript	Type safety, IDE support
Backend	Firebase	Auth + Firestore (existing infrastructure)
Server State	React Query	Caching, mutations, optimistic updates
Client State	Zustand	Minimal boilerplate, persist middleware
Forms	React Hook Form + Zod	Validation, error handling

The Secret: 94% Code Reuse

The biggest accelerator wasn’t a framework or library - it was architectural consistency between the web and mobile codebases.

Python Class Identity Mismatch: The CI Bug That Broke 9 PRs

Fri, 12 Dec 2025 00:00:00 +0000

The Problem: CI Failing Everywhere

Picture this: You have 9 open pull requests, all failing CI with the same cryptic error. The test assertions show objects that look correct but fail isinstance() checks.

AssertionError: PipelineResult(...) is not an instance of <class 'agents.shared_contracts.PipelineResult'>

The object has every field. The data is correct. But Python says it’s not the right type.

Root Cause: Class Identity Mismatch

Python determines class identity by the module path where the class was defined. When you import the same class via different paths:

Designing a Local-First Resume Parser: Architecture Decisions for Edge AI

Thu, 11 Dec 2025 00:00:00 +0000

The Problem I Want to Solve

Recruiters pay $0.05-$0.20 per document to cloud parsing services like DaXtra, RChilli, and Affinda. Beyond cost, there’s a privacy issue: candidate data leaves the device and travels to vendor servers.

I want to explore whether browser-based AI can eliminate both problems.

Project Status: Planning Complete, Build Starting

I’ve completed the architecture planning phase:

PRD defining MVP scope
6 Architecture Decision Records (ADRs)
89-task implementation plan across 8 weeks

No production code yet. This post documents the planned architecture, not a working system.

How to Get Your ADK Agent into Google's Official Community Showcase

Thu, 11 Dec 2025 00:00:00 +0000

How to Get Your ADK Agent into Google’s Official Community Showcase

Last week, Bob’s Brain became one of only 4 projects in Google’s official Agent Starter Pack community showcase. Here’s the tactical playbook for how we got there—and what it means for your ADK projects.

The Numbers That Matter

Metric	Value
Repository Stars	3,690
Total Forks	1,041
External Contributors	1 (us)
Community Showcase Projects	4

Out of 1,041 forks, we’re the only external contributor. That’s a 0.1% conversion rate from “forked the repo” to “actually contributed back.”

BigQuery Integration, 23 Skills at L4 Quality: Nixtla v1.8.0

Wed, 10 Dec 2025 10:00:00 -0600

26 commits. The day the three plugins stopped being independent projects and started being a pipeline.

Four days of infrastructure, quality enforcement, and security hardening led to this: the moment where separate components become a system. v1.8.0 isn’t the biggest release by commit count. It’s the most important by what it proves — three independently developed plugins can compose into a reliable workflow with tested failure handling.

3-Plugin Workflow Integration

Each plugin had been built and tested in isolation. Search-to-slack finds information. Baseline Lab runs forecasts. BigQuery Forecaster queries production data. All three worked. None of them talked to each other.

Security Hardening and Docs Redesign: Nixtla v1.7.0

Tue, 09 Dec 2025 10:00:00 -0600

20 commits. The theme was trust: can someone clone this repo, understand what it does, and trust that it won’t do anything unexpected?

After four days of building infrastructure, features, and quality tooling, v1.7.0 is the release that makes the repo presentable to someone outside the development team. Security boundaries, comprehensive guides, a navigable tree, and a README that respects the reader’s time.

Security Hardening for Skills

Skills execute code. That’s the point. But executing code from a SKILL.md file that was last audited three spec versions ago is a different kind of trust than running a pinned dependency from PyPI.

21 Skills and a Production Validator: Nixtla v1.6.0

Mon, 08 Dec 2025 10:00:00 -0600

66 commits. The biggest single-day push the Nixtla repo has seen. Three major workstreams running in parallel: skill extraction, validator construction, and TimeGPT lab expansion. Each one would have been a reasonable day on its own.

The commit rate was sustainable because yesterday’s CI optimization eliminated the feedback loop bottleneck. Every push validated in under a minute. That changes behavior — you commit smaller, more frequently, with higher confidence. The 66 commits aren’t 66 features. They’re 66 incremental steps where each one was tested before the next began.

CI Cost Optimization and Code Quality Enforcement: Nixtla v1.5.0

Sun, 07 Dec 2025 10:00:00 -0600

22 commits. Most of them were about spending less money on things that don’t need to be expensive.

The Nixtla workspace hit v1.5.0 today. Not a feature release — a governance release. Every commit was about making the existing codebase cheaper to run, safer to maintain, and easier to read. The kind of release where the changelog is boring and the impact is permanent.

The CI Cost Problem

The Nixtla workspace had been running every check on every push. Full test suite, linting, type checking, documentation validation, secrets scanning — all of it, every time, regardless of what changed. A typo fix in a README triggered the same 8-minute pipeline as a core forecasting algorithm change.

Gemini PR Reviews and Four Releases in One Day

Sat, 06 Dec 2025 10:00:00 -0600

54 commits. Four releases. And a debugging journey through three different Gemini configurations before PR reviews actually worked.

The Gemini PR Review Pipeline

The goal: automated code review on every PR to the Nixtla repo. An AI reviewer reads the diff, checks for compliance violations, flags potential issues, and posts a structured review comment. The reviewer is Gemini, because the free tier is generous enough for a repo this size.

Global Skill Schema and a Prediction Markets Vertical

Fri, 05 Dec 2025 10:00:00 -0600

106 files. 11,951 lines. The day split into two halves: standardizing how skills get built, then proving the standard works by building a new vertical from it. Standards that exist without implementations are aspirational. Standards that ship with a working example are real.

Global Standard Skill Schema

The 8 skills from Dec 1 followed a structure. But that structure lived in tribal knowledge and copy-paste. Today it became a formal specification.

v1.2.0: Every Skill to 100% Compliance

Thu, 04 Dec 2025 10:00:00 -0600

24 commits. One release. The entire day was compliance remediation. Not the glamorous kind of engineering. The kind that makes everything else work correctly.

The Starting Point

The skills infrastructure built on Dec 1 had the right structure but loose compliance. Each SKILL.md file scored between 38% and 40% against the compliance checker. Missing required fields, incomplete schemas, permissions that didn’t match actual plugin requirements, usage examples that wouldn’t parse.

CEO Quickstart Guide and DeFi Sentinel Exploration

Wed, 03 Dec 2025 10:00:00 -0600

Two very different writing tasks today. One document optimized for a specific person. Six documents exploring a product that might not exist in a month. Four commits total, but the line count tells the real story: 4,798 lines of DeFi exploration and 203 lines of the most carefully edited document in the repo.

CEO Quickstart: 203 Lines for Max

The Nixtla workspace has thorough documentation. Architecture docs, API references, deployment guides, compliance audits. What it didn’t have was a document that answers: “I’m Max. I have 10 minutes. What does this do and how do I show it to someone?”

Implementing Brand Consistency with CSS Variables: A Sponsor Page Redesign

Tue, 02 Dec 2025 02:40:00 -0600

When your sponsor page looks like it belongs to a different website than your homepage, you have a brand consistency problem. Here’s how I fixed it—and what I learned about the iterative process of design system migration.

The Problem: Three Different Color Schemes

The Claude Code Plugins marketplace had evolved organically. The homepage used Anthropic’s warm, professional brand colors (orange, green, earthy tones). The sponsor page? Still using generic blue CTAs and inconsistent grays from an earlier design phase.

Skills Infrastructure from Scratch: 8 SKILL.md Files, an Installer, and a Compliance Framework

Mon, 01 Dec 2025 10:00:00 -0600

53 files. 13,445 lines. One goal: give the Nixtla workspace a skills layer that doesn’t exist yet.

What Needed Building

The Nixtla workspace had plugins. It had documentation. It had release discipline. What it didn’t have was a way for external tools to discover and invoke its capabilities through a standardized interface.

Skills are that interface. A SKILL.md file declares what a skill does, what inputs it needs, what outputs it produces, and what permissions it requires. An installer package reads those declarations and wires them into Claude Code. A demo project proves the whole chain works end-to-end.

November 2025: The Depth Month — Fewer Posts, Triple the Commits

Sun, 30 Nov 2025 18:00:00 -0600

October said “write everything.” November said “ship everything.” The numbers tell the story: post count dropped 60% while commits more than doubled. That’s what depth over breadth looks like in practice.

Velocity Dashboard

Metric	November 2025	October 2025	Delta
Posts Published	18	45	-60%
Commits	516	220	+135%
Posts Classified	16	11	+45%
T1 (Deep-Dive / Case Study)	11 (69%)	5 (45%)	+24pp
T2 (Field Note)	5 (31%)	6 (55%)	-24pp
Avg Confidence Score	0.88	0.89	-0.01
Classification Rate	89%	24%	+65pp

Every trend moved in the right direction. 89% classification rate versus October’s 24% — that was the number one goal and it’s basically solved. The T1 rate jumping to 69% means the posts that did get written were substantial. No more “today I updated a dependency” filler.

Three Releases in One Day: Nixtla Goes Enterprise

Sun, 30 Nov 2025 10:00:00 -0600

30 commits. Three releases. Zero new features. The entire day was restructuring what already existed into something a CEO would show to investors.

v0.8.0: Doc-Filing Compliance

The Nixtla workspace had accumulated documentation organically. READMEs next to scripts next to architecture notes next to meeting prep. Functional but unsearchable.

Doc-Filing v3.0 compliance imposed structure: consolidated docs directory, sequential numbering, standardized naming convention. Every document got a number, a category code, and a descriptive slug. The kind of reorganization that feels like busywork until the third time you can’t find something.

Nixtla BigQuery Forecaster: Cloud Functions on 200 Million Rows

Sat, 29 Nov 2025 10:00:00 -0600

Plugin #2. The Baseline Lab proved statsforecast works on curated datasets. The BigQuery Forecaster proves it works on real data at real scale.

The Plugin

A Cloud Function (Python 3.12) that queries BigQuery public datasets, runs AutoETS and AutoTheta forecasts, and returns structured results. The target dataset: Chicago taxi trips — 200 million+ rows of timestamped ride data with fare amounts, trip durations, and pickup locations.

2,691 lines across 16 files. That’s a complete plugin: source code, tests, deployment config, CI workflow, and documentation. The file count breaks down as: 4 Python source files, 3 test files, 2 deployment configs (Cloud Functions + GitHub Actions), 1 requirements file, and 6 documentation files including the README, architecture doc, and usage examples.

GitHub Profile Refresh and Nixtla Review Readiness

Wed, 26 Nov 2025 10:00:00 -0600

Polish day. Three repos, zero new features, all preparation. The kind of day that doesn’t feel productive until someone actually reads what you wrote.

The work was split across github-profile (3 commits), nixtla (8 commits), and perception (1 commit). Twelve commits total. Every single one touched a markdown file or a shell script. Not a single Python function was modified.

GitHub Profile: 305 Lines Down to 135

The GitHub profile README had accumulated cruft. 305 lines of badges, project lists, and metrics that hadn’t been verified in months. Half the stats were wrong. Two project links were dead.

Nixtla Baseline Lab: Phases 4 Through 8 in a Single Day

Tue, 25 Nov 2025 10:00:00 -0600

34 commits. Five phases. One day. The Nixtla Baseline Lab went from a test bed to a real product between breakfast and dinner.

Phase 4: Testing and Skills Wiring

Phase 4 was plumbing. Test coverage for the existing baseline functions, skills wiring to expose them through the dev marketplace, and a marketplace entry so other tools could discover and invoke the lab. Nothing flashy. The kind of work that makes everything after it possible.

Nixtla Baseline Lab: Real statsforecast Baselines via MCP Server

Mon, 24 Nov 2025 10:00:00 -0600

Yesterday was plugin scaffolding. Today the Baseline Lab gets real models running real data through a real MCP server.

Phase 2: Plugin Manifest and MCP Config

The Baseline Lab plugin needed two pieces of infrastructure before any forecasting code could run.

Plugin manifest. Standard plugin.json declaring the plugin’s name, version, dependencies, and MCP server configuration. The MCP config tells Claude Code how to start the server, what tools it exposes, and what permissions it needs (filesystem read for data files, network for optional Nixtla cloud API calls).

Nixtla Repo: Zero to v0.2.0 with a Working Search-to-Slack Plugin

Sun, 23 Nov 2025 10:00:00 -0600

New repo. Empty directory. By end of day: v0.2.0 tagged, a working plugin shipping, and a GitHub Pages site live.

Repository Initialization

The Nixtla Claude Code plugins workspace needed proper infrastructure from commit one. Not a README and a prayer – actual CI/CD, documentation filing, and GitHub Actions workflows.

First commit: project scaffolding with GitHub Actions for CI, automated doc filing using the standard 000-docs numbering scheme, and a base configuration for the plugin workspace. GitHub Pages site deployed from the repo’s docs output.

Scout Agent Deployment Saga: Python SDK Fails, CLI Saves, REST API Discovered

Wed, 19 Nov 2025 10:00:00 -0600

The Scout Team

HustleStats needed intelligent scouting reports. Not template-filled stat summaries – actual analysis that cross-references a player’s stats against league averages, identifies trends, and produces recruiting-grade assessments.

The architecture: a Lead Scout orchestrator that delegates to four specialist agents.

Stats Logger – ingests raw game data, normalizes across different scoring formats, maintains per-player longitudinal records
Performance Analyst – computes percentile rankings within position groups, identifies statistically significant trends across a minimum 5-game window
Recruitment Advisor – maps player profiles to recruiting criteria for travel teams and club programs, surfaces fit scores
Benchmark Specialist – maintains league-wide and national percentile baselines, adjusts for age group and competition level

All five agents run Gemini 2.0 Flash. The Lead Scout uses function calling to delegate to specialists and synthesize their outputs into a single scouting report.

PostgreSQL Decommission, Monitoring Stack, and HustleStats v1.0.0

Tue, 18 Nov 2025 10:00:00 -0600

31 commits in a single day. Not 31 features – 31 cleanup, hardening, and shipping tasks that turned a working prototype into a released product. The commit volume sounds dramatic. The reality is unglamorous. This was the grind that makes software real.

PostgreSQL Decommission

HustleStats started on PostgreSQL with Prisma as the ORM. The data layer migrated to Firestore months ago, but the Prisma dependency lingered – unused schema files, legacy route handlers, and a healthcheck endpoint that still pinged a Postgres connection string that no longer existed.

Building an Idempotent Stripe Billing Enforcement Engine for Firestore

Mon, 17 Nov 2025 22:15:00 -0600

When you’re building subscription billing with Stripe webhooks, you quickly discover a harsh reality: webhooks can arrive delayed, duplicated, or out of order. For a youth sports stats SaaS platform I’m building, this created a critical problem—plan and status updates were scattered across multiple handlers with no guarantee of consistency.

This is the story of building a unified plan enforcement engine that solved webhook chaos, eliminated duplicate logic, and added automatic drift correction—all while maintaining a complete audit trail.

HustleStats Launch Sprint: From Firebase Auth to Production SaaS with Stripe Billing in One Day

Sun, 16 Nov 2025 10:00:00 -0600

The Starting Point

Yesterday ended with 7 dashboard pages running on Firebase Auth. The app could authenticate users and display their data. What it couldn’t do: charge money, enforce plan limits, or prevent free users from accessing paid features.

Today’s goal: ship a complete billing system. Not “billing someday” — billing today, with Stripe checkout, webhooks, plan enforcement, and a customer portal.

33 commits. Four phases.

Phase 4: Final Prisma Cleanup

Before adding anything new, the last traces of PostgreSQL needed to go.

HustleStats Firebase Auth Cutover: 7 Dashboard Pages, 3-Layer Defense, Zero Prisma

Sat, 15 Nov 2025 10:00:00 -0600

The Firebase migration (Days 2-7) gave HustleStats a new auth system and data layer. Today was the cutover — making every dashboard page actually use it.

Phase 1: Planning and Staging

Before touching code, I mapped every page that imported NextAuth or Prisma:

Dashboard home
Player list + detail
Game entry + detail
Stats overview
Settings/profile

Seven pages total. Each one imported getServerSession from NextAuth and made Prisma queries for data. Every page needed both the auth and data layer swapped.

Perception Agent System: Zero to MCP Server and Dashboard in One Day

Fri, 14 Nov 2025 10:00:00 -0600

The Problem

I wanted a system that could monitor news feeds, detect emerging trends, and surface relevant articles without manual curation. Not a feed reader — a multi-agent intelligence platform where specialized agents handle different aspects of the news pipeline: ingestion, deduplication, relevance scoring, topic classification, trending detection, summarization, alerting, and archival.

The project name: Perception. GCP project: perception-with-intent.

The constraint: build the entire system — agents, MCP service, dashboard, infrastructure — in one day.

HustleStats Firebase Migration Days 2-7: Schema, Auth Swap, Data Port, and the Cost Cliff

Tue, 11 Nov 2025 10:00:00 -0600

Six days. Four commits. The entire HustleStats backend moved from PostgreSQL + NextAuth to Firebase.

Day 2: Firestore Schema

The Firestore subcollection hierarchy follows the access pattern:

users/{uid}
 └── players/{pid}
 └── games/{gid}

Every query starts with a user. Players belong to a user. Games belong to a player. The hierarchy means security rules can enforce ownership at every level without extra lookups. A read to users/abc/players/xyz/games/123 already proves the caller owns the path.

HustleStats Firebase Migration: 5-Agent A2A Architecture on Day One

Mon, 10 Nov 2025 10:00:00 -0600

Four commits to kick off the HustleStats Firebase migration. The previous stack – Next.js on Cloud Run with Prisma and PostgreSQL – worked but cost $72/month for a youth sports app with minimal traffic. Firebase brings that down to an estimated $20/month. The tradeoff is a complete backend rewrite.

The 5-Agent A2A Architecture

HustleStats is a youth soccer statistics tracker. Parents log games, coaches review performance, kids see their highlights. The new backend uses Google’s Agent-to-Agent (A2A) protocol with five agents:

Fine-Tuning IAM1: Building a Hierarchical Multi-Agent System on Vertex AI

Sun, 09 Nov 2025 20:45:00 -0600

The Problem: Generic Orchestrator vs Business-Aligned Regional Manager

I had Bob deployed as a basic multi-agent orchestrator on Vertex AI Agent Engine. But here’s what was wrong:

Before Fine-Tuning:

Generic “master orchestrator” identity
Vague routing decisions
No clear decision framework
IAM2 specialists had generic instructions
Missing business model alignment

What I Needed:

IAM1 as a Regional Manager (sovereign in domain)
Clear hierarchy: IAM1 can command IAM2s, can coordinate with peer IAM1s
Intelligent routing based on task complexity
Professional IAM2 specialists with standardized deliverables
Alignment with IntentSolutions business model (deployable per client)

This wasn’t just about better prompts. It was about transforming a generic agent into a deployable business product.

Building an AI Video Pipeline with Vertex AI Veo, Lyria, and GitHub Actions

Sat, 08 Nov 2025 10:00:00 -0600

The Goal

Build a CI/CD pipeline that produces documentary-style video content about NWSL soccer. Not a one-off script. A repeatable, trigger-on-push system that generates video segments, scores them with AI music, assembles the final cut, and watermarks the output.

The media APIs are Vertex AI Veo (video generation) and Vertex AI Lyria (music generation). The orchestration is GitHub Actions. The assembly is ffmpeg. Over 23 commits and 53,000+ lines, the pipeline went from a blank repo to a working end-to-end system.

Model-Agnostic Positioning and the IAE Branding Back-and-Forth

Mon, 03 Nov 2025 10:00:00 -0600

Six commits on the Intent Solutions landing site today. The throughline: figuring out how to position an AI agent product when the product itself is still forming.

The Model-Agnostic Pivot

The landing page started with IAE (Intelligent Automation Engine) branding front and center. IAE is PipelinePilot’s agent framework – specific tools, specific architecture, specific Vertex AI integration. But Intent Solutions is not just PipelinePilot. The company offers consulting, custom agent builds, and integration work across multiple platforms.

Vertex AI Agent Engine Forced a Same-Day Architecture Pivot

Sat, 01 Nov 2025 10:00:00 -0600

The Plan That Died on Deployment

PipelinePilot had a clean four-agent architecture. Orchestrator routes to Research, Enrichment, and Outreach. Each agent owns its tools. Each agent has a single responsibility. The Python ADK migration from YAML was already done. CI passed. Local tests passed.

Then I deployed to Vertex AI Agent Engine and the entire multi-agent topology fell apart.

Agent Engine cannot have multiple non-search tools on a single agent.

October 2025: Month One — Baseline Established

Fri, 31 Oct 2025 18:00:00 -0500

First month of tracking. No previous baseline. No trend lines. Just raw numbers from a month where I launched a marketplace, shipped a multi-agent SDR system, survived a production auth crisis, and still found time to redesign a landing page.

This is the month everything starts getting measured.

Velocity Dashboard

Metric	October 2025	Delta
Posts Published	45	— (baseline)
Commits	220	— (baseline)
Posts Classified	11	—
T1 (Deep-Dive / Case Study)	5 (45%)	—
T2 (Field Note)	6 (55%)	—
Avg Confidence Score	0.89	—
Classification Rate	24%	—
Commits per Post	4.9	—

45 posts in one month is aggressive. At the time I thought “just document everything.” In hindsight, some of those were thin. The tier system hadn’t fully kicked in yet — only 11 of 45 posts got classified. That’s a 24% classification rate, which is terrible. The system was new. I was still calibrating what counts as a real post versus noise.

PipelinePilot: Building a Multi-Agent SDR Orchestrator on Vertex AI in One Day

Fri, 31 Oct 2025 10:00:00 -0500

The Problem Nobody Talks About

Sales development pipelines are stitched together with duct tape. A typical SDR stack looks like this: Apollo for contact discovery, ZoomInfo for enrichment, a CRM for tracking, a sequencing tool for outreach. Each one has its own login, its own API, its own data model. The SDR spends half their day copying data between tabs.

The answer isn’t another SaaS integration platform. It’s agents that own the workflow end to end.

Building a Production Multi-Agent AI System: BrightStream's 10-Agent Architecture on Vertex AI

Thu, 30 Oct 2025 01:30:00 -0600

Building a Production Multi-Agent AI System: BrightStream’s 10-Agent Architecture on Vertex AI

The Journey from Concept to Infrastructure in One Session

I just built BrightStream - a production-ready positive news platform powered by 10 independent AI agents orchestrated through Google’s Vertex AI Agent Engine. This isn’t a tutorial with a clean solution. This is the real story: the confusion, the pivots, the “wait, how does this actually work?” moments that happened over the last few hours.

Architecting a Production Multi-Agent AI Platform: Technical Leadership in Action

Wed, 29 Oct 2025 21:30:00 -0500

Architecting a Production Multi-Agent AI Platform: Technical Leadership in Action

From Concept to Infrastructure: A Case Study in Systematic Problem-Solving

Over the past few hours, I architected and deployed BrightStream - a production-grade positive news platform powered by 10 independent AI agents orchestrated through Google’s Vertex AI Agent Engine. This case study demonstrates systematic technical decision-making, cost optimization, and infrastructure automation.

Project Scope:

10 ADK-compliant agent configurations
Complete GCP infrastructure automation
Docker-based development environment
Multi-agent orchestration with parallel execution
89% cost reduction through architectural optimization ($1,548 → $168/month)

The Challenge: Choosing the Right Architecture

The initial approach was workflow-based (n8n) - visual, accessible, easy to demonstrate. But this created a fundamental mismatch between the tool and the problem.

IAE Product Architecture: Building a Sellable AI Agent with A2A Protocol and Modular Pricing

Mon, 27 Oct 2025 10:00:00 -0500

Most AI agent projects die as consulting engagements. Someone builds a custom workflow, charges hourly, and the moment they stop touching it, the client churns. The agent was never a product — it was a service wearing a product’s clothes.

I spent the last week turning our intelligence agent into something with a SKU. The result is the Intent Agent Engine (IAE): a two-layer architecture built on Google’s A2A Protocol, with modular pricing that lets customers buy exactly the capability they need. Here’s how the architecture decisions drove the pricing, and why the obvious approach — one agent, one price — would have killed the business.

Productizing AI Agents: Containerized Offerings and the 9-Commit Iteration Loop

Sun, 26 Oct 2025 10:00:00 -0500

Sunday evening. 9 PM. I had three AI agent concepts that worked in demos but had no public packaging. By 11 PM I had a product page, had promoted it to hero position, reverted that decision, and repositioned the entire offering for a different market. Nine commits. The git log reads like a product strategy argument with yourself.

The Starting Point: Agents Without a Home

The Intent Solutions landing site had service offerings, but the AI agents existed only as internal prototypes. LinkedIn Outbound automation. Meeting intelligence summarization. Customer support triage. Each worked. None had pricing, packaging, or a public page.

NEO: How to Build Vision-Language Models That Actually Understand Images

Sat, 25 Oct 2025 22:30:00 -0600

On October 2025, researchers from S-Lab (NTU), Xi’an Jiaotong University, and SenseTime published NEO: a vision-language model that matches GPT-4V performance while using only 390 million training examples instead of billions.

More importantly, they proved native VLMs (vision and language from scratch) can compete with modular systems (bolting vision onto existing LLMs).

This isn’t just an academic achievement. It’s a blueprint for building efficient multimodal AI without Google-scale infrastructure.

The Problem: Why Most Vision-Language Models Are Frankenstein Creations

Here’s how 90% of vision-language models work today:

How to Train AI Research Agents Without Spending $100K on Human Annotations

Sat, 25 Oct 2025 15:30:00 -0600

On October 17, 2025, a team from Pokee AI published research that solves a problem costing AI companies hundreds of thousands of dollars: how to train intelligent research agents without paying humans to grade every answer.

Their solution—PokeeResearch-7B—runs on consumer GPUs, beats larger proprietary models, and is fully open source.

This isn’t just an academic achievement. It’s a blueprint for building production-ready AI research tools without burning cash on annotation teams.

The Coasean Singularity: How AI Agents Will Transform Digital Markets

Fri, 24 Oct 2025 15:00:00 -0500

Executive Summary

In 2025, researchers from NBER published groundbreaking analysis on how autonomous AI agents will fundamentally reshape digital markets through dramatic reductions in transaction costs. The paper “The Coasean Singularity? Demand, Supply, and Market Design with AI Agents” examines what happens when AI systems can search, negotiate, and transact independently on behalf of humans—potentially reaching a “singularity” where transaction costs approach zero.

Key Insight: AI agents aren’t just tools—they’re market participants that could enable entirely new economic structures previously impossible due to high transaction costs.

Fixing Claude Code EACCES: Multi-User Linux Permission Architecture

Thu, 23 Oct 2025 14:45:00 -0600

When you’re running Claude Code across multiple Linux user accounts and hit EACCES: permission denied, the solution isn’t just chmod 777. This is the complete troubleshooting journey from error to production-ready multi-user architecture.

The Problem: Two Users, One Claude Code Instance

Initial symptom: User jeremy couldn’t start Claude Code:

EACCES: permission denied, open
syscall: "open",
 errno: -13,
 code: "EACCES"

Context:

Two user accounts: jeremy (master) and admincostplus (admin)
Both need to run Claude Code independently
Shared configuration desired (plugins, MCP servers, slash commands)
No permission conflicts or ownership battles

The naive approach? “Just give both users access.” The correct approach? Architect a system that scales.

Deployment Secrets, Missing Columns, and Sitemap Hygiene

Wed, 22 Oct 2025 10:00:00 -0500

Three commits across two repos today. No theme, no arc – just the kind of maintenance work that keeps production systems from embarrassing you.

HustleStats: Email Configuration

Password reset was broken in production. Users clicking “Forgot Password” got nothing – no email, no error message on the frontend, just silence. The Resend API integration was wired up correctly in the application code, the email templates existed, and everything worked in local development. The problem was upstream in the deployment pipeline.

HustleStats Production Auth Meltdown: NextAuth, PrismaAdapter, and the Cascade That Blocked Every User

Tue, 21 Oct 2025 10:00:00 -0500

The Customer Was Blocked

A user tried to log into hustlestats.io and got a generic “Configuration” error. No stack trace. No useful message. Just a NextAuth error page with a single word.

This was a paying customer on a custom domain. The app had been working in development. It had been working on the default Vercel URL. But on the production custom domain, login was completely dead.

What followed was a 14-commit debugging marathon where every fix uncovered a new failure. The kind of session where you fix the auth, then registration breaks, then emails break, then the database schema is wrong, and you realize the entire deployment pipeline had been silently broken for days.

Intent Solutions Portfolio 2025: Five Production Platforms and the Architecture Behind 4-Day Deployments

Mon, 20 Oct 2025 23:45:00 -0600

When you see “deploy in days, not months,” it sounds like marketing fluff. This is the technical breakdown of how Intent Solutions actually does it—with five production platforms serving real customers, measurable cost optimization, and architecture patterns you can replicate.

The Portfolio: Five Production Platforms

Platform Overview

Platform	Purpose	Tech Stack	Status	Key Metric
DiagnosticPro	AI vehicle diagnostics	React 18, Firebase, Vertex AI	Production	96.4% gross margin
Hustle	Youth sports recruiting stats	Next.js 15, PostgreSQL, Cloud Run	Live beta	COPPA-compliant auth
CostPlusDB	Transparent database hosting	PostgreSQL 16, AWS, pgBackRest	Production	68% cost savings vs AWS
ClaudeCodePlugins	Plugin marketplace	Next.js 15, Cloud Run	Live	236 production plugins
Intent Solutions	Company landing	Astro 5, Tailwind CSS 4	Production	4-day concept→deploy

Combined infrastructure: Google Cloud Platform (primary), AWS (secondary), Netlify (static sites), Firebase (customer platforms).

Intent Solutions Portfolio 2025: Five Production Platforms and the Architecture Behind 4-Day Deployments

Mon, 20 Oct 2025 23:45:00 -0600

The Portfolio: Five Production Platforms

Platform Overview

Platform	Purpose	Tech Stack	Status	Key Metric
DiagnosticPro	AI vehicle diagnostics	React 18, Firebase, Vertex AI	Production	96.4% gross margin
Hustle	Youth sports recruiting stats	Next.js 15, PostgreSQL, Cloud Run	Live beta	COPPA-compliant auth
CostPlusDB	Transparent database hosting	PostgreSQL 16, AWS, pgBackRest	Production	68% cost savings vs AWS
ClaudeCodePlugins	Plugin marketplace	Next.js 15, Cloud Run	Live	236 production plugins
Intent Solutions	Company landing	Astro 5, Tailwind CSS 4	Production	4-day concept→deploy

Combined infrastructure: Google Cloud Platform (primary), AWS (secondary), Netlify (static sites), Firebase (customer platforms).

October 2025 State of Affairs: Five Production Platforms and What They Taught Me

Mon, 20 Oct 2025 23:30:00 -0500

The Reality Check

Twenty months ago, I was writing restaurant schedules and managing food costs. Today, I’m running five production platforms serving real customers, maintaining 236 Claude Code plugins, and consulting on AI automation.

This isn’t a success story. It’s a progress report from someone who’s learning in public.

What’s Actually Running in Production

DiagnosticPro: 96.4% Margin AI Platform

What it does: AI-powered vehicle diagnostics using Google Vertex AI Gemini 2.5 Flash.

How I Built a Production-Ready Research Tool That Outperforms Anthropic's Solution

Mon, 20 Oct 2025 21:58:00 -0500

On October 20, 2025, Anthropic announced Claude for Life Sciences - a suite of research tools for scientific literature. That same evening, I built something better: a production-ready PubMed research toolkit with 10 MCP tools, comprehensive test coverage, and zero security vulnerabilities.

This is how I approached the problem, the critical decisions I made, and why simpler solutions often win.

The Challenge: Build Better, Not Compete

When I saw Anthropic’s announcement, I didn’t think about competition. I thought about user value:

Scaling AI Systems: Production Batch Processing with Built-In Disaster Recovery

Sun, 19 Oct 2025 23:50:00 -0500

The Challenge: Scale AI Documentation Across 235 Production Systems

When you maintain a plugin marketplace with 235 live integrations, manual documentation doesn’t scale. Each plugin needed 8,000-14,000 byte enhancement files following official Anthropic standards - a multi-week manual effort.

My approach: Build an overnight batch processing system using Vertex AI Gemini 2.0 Flash, staying entirely within free tier limits while maintaining 100% success rate and full disaster recovery capabilities.

This case study demonstrates systems thinking, risk management, and production-grade automation under real constraints.

Scaling AI Batch Processing: Enhancing 235 Plugins with Vertex AI Gemini on the Free Tier

Sun, 19 Oct 2025 22:00:00 -0500

The Problem: 235 Plugins Need Comprehensive Documentation

I maintain claude-code-plugins, a marketplace with 235 plugins for Claude Code. Each plugin needed enhanced SKILL.md files (8,000-14,000 bytes) following Anthropic’s Agent Skills standards. Doing this manually would take weeks.

The goal: Process all 235 plugins overnight using Vertex AI Gemini 2.0 Flash - entirely on the free tier.

The constraints:

Must stay within Vertex AI free tier limits
Need 100% success rate (no corrupted files)
Require full audit trail for compliance
Zero tolerance for API quota violations

The Journey: From Ultra-Conservative to Optimized

Phase 1: Initial System Design

I built overnight-plugin-enhancer.py with these core components:

GCR to Artifact Registry: Late-Night Deploy Fix

Sat, 18 Oct 2025 10:00:00 -0500

The 1 AM Deploy Session

Hustle deploys had been failing. The symptom was a cryptic “retry budget exhausted” error during Docker push in the GitHub Actions workflow. The root cause: Google Container Registry (GCR) at gcr.io was deprecated. Google had been routing GCR traffic through Artifact Registry for a while, but the old push endpoints were finally returning errors consistently enough to break CI.

Two commits, four minutes apart, at 1:24 and 1:28 AM. The kind of session where the goal is simple: fix the registry, fix the phantom secret, verify green, go to bed.

Building Production-Grade CI/CD: From Documentation Chaos to Automated Deployment

Fri, 17 Oct 2025 22:30:00 -0500

The Professional Challenge

I spent today tackling a problem every growing engineering team faces: the gap between “it works on my machine” and true production readiness. My youth sports statistics platform (HustleStats) had reached that critical inflection point where manual deployments and scattered documentation were becoming serious technical debt.

The wake-up call came in the form of multiple failed deployment emails. ESLint failures. Workflow conflicts. Wrong GCP project references. The kind of cascading issues that signal deeper systemic problems rather than isolated bugs.

Debugging a Critical Marketplace Schema Validation Failure: How One Invalid Field Blocked All Installations

Thu, 16 Oct 2025 22:30:00 -0600

At 10:16 PM ET on October 16th, 2025, a user reported they couldn’t install the Claude Code Plugins marketplace. The error message was clear but devastating:

✘ Failed to add marketplace: Invalid schema: plugins.1: Unrecognized key(s) in object: 'enhances'

Impact: ZERO users could install the marketplace. Complete installation failure.

This is the story of how we debugged it, fixed it, added legal compliance, resolved CI/CD issues, and deployed security improvements - all in under 3 hours.

Marketplace CI Hardening: Sync Guard, Plugin Scaffold, and 15 PRs in a Day

Wed, 15 Oct 2025 10:00:00 -0500

Five days after the Claude Code plugin marketplace launched, we had a problem. The repo was attracting contributors and dependency updates faster than manual review could handle. Eight Dependabot PRs sat waiting for a human to click merge. A schema collision in the marketplace data had broken the site. And every new contributor had to reverse-engineer the plugin format from existing examples.

The fix was not more humans reviewing PRs. The fix was governance automation — letting machines handle the predictable decisions so humans could focus on the interesting ones.

First External Contributor, Spotlight Infrastructure, and a 9,770-Line Delete

Tue, 14 Oct 2025 10:00:00 -0500

A marketplace that only accepts your own code isn’t a marketplace. It’s a portfolio.

The Claude Code plugin hub launched on October 10th with 225+ plugins. All mine. The site was live, the CI pipeline was running, the validation framework was scoring badges. But there was an uncomfortable question hanging over it: would anyone else actually contribute?

Four days later, @cdnsteve submitted the Sugar plugin. First external contribution to the Claude Code plugin hub. The merge itself was straightforward. What wasn’t obvious was how much infrastructure you need to make that moment visible to everyone who visits the site afterward.

Marketplace Security Framework and the False Positive Fight

Mon, 13 Oct 2025 10:00:00 -0500

Three days after launching the Claude Code plugin marketplace, the security story was “trust me, I checked.” That needed to change before anyone installed a community plugin on their machine.

The Security Framework

The day started with a full SECURITY.md — 407 lines covering a 6-vector threat model, three trust tiers (Community, Verified, Featured), responsible disclosure policy, and SLA commitments. Standard structure, but adapted to the plugin marketplace context where users execute community code inside their development environment.

Marketplace Scaling: Learning Paths, Finance Plugins, and Social Sharing Fixes

Sun, 12 Oct 2025 10:00:00 -0500

The marketplace had 225 plugins and no answer to “where do I start?”

That question kept showing up. New users would land on the plugin directory, scroll past hundreds of entries, and leave. Power users knew what they wanted. Everyone else bounced. October 12th was about fixing that gap — plus two new domain plugins, a crypto spotlight, and social sharing fixes that had been bugging me for weeks.

Learning Paths: 9,347 Words of Structured Guidance

Seven learning paths shipped in a single PR. Not a docs page with bullet points. Actual structured guides with visual roadmaps, time estimates, and prerequisite chains.

Deploying Next.js 15 to Google Cloud Run: From Zero to HTTPS in 2 Hours

Sat, 11 Oct 2025 19:30:00 -0600

I just deployed ClaudeCodePlugins.io from scratch to production on Google Cloud Run with custom domain and SSL. Here’s the complete journey with every error, fix, and lesson learned.

The Goal

Deploy a Next.js 15 application to Google Cloud Run with:

Custom domain (www.claudecodeplugins.io)
Google-managed SSL certificate
Global load balancer with HTTP/2
Serverless auto-scaling (0-10 instances)
Production-grade infrastructure as code

Starting point: A working Next.js 15 app on localhost.

Target: Live site with HTTPS at a custom domain.

Launching the Claude Code Plugin Marketplace: From Gumroad to Open Source in One Day

Fri, 10 Oct 2025 10:00:00 -0500

The morning Anthropic announced Claude Code extensibility, the commercial Gumroad model I’d been building died. Not slowly. Instantly. The smart move was obvious: open source everything, ship a marketplace, and grab first-mover advantage before anyone else reacted.

This is how 13 commits, 53,000+ insertions, and one hard pivot produced a production plugin marketplace in under 24 hours.

The Problem: A Commercial Model That Couldn’t Survive

I’d been building Claude Code plugins as a paid product. Gumroad storefront, tiered pricing, the works. Then Anthropic’s announcement made it clear: the ecosystem was going open. Trying to sell individual plugins against a flood of free community contributions would be like charging for npm packages.

NLWeb: Building the AI Web with Natural Language Interfaces

Thu, 09 Oct 2025 19:30:00 -0600

Overview

NLWeb is an open-source framework from Microsoft that simplifies building conversational interfaces for websites. It represents a foundational shift in how we think about web interaction—moving from traditional search and navigation to natural language conversations with structured data.

Key Innovation: NLWeb natively supports Model Context Protocol (MCP), allowing the same natural language APIs to serve both humans and AI agents. As the project states: “NLWeb is to MCP/A2A what HTML is to HTTP.”

Debugging Slack Integration: From 6 Duplicate Responses to Instant Acknowledgment

Thu, 09 Oct 2025 03:30:00 -0600

The Problem: Bob Responded 6 Times to Every Message

I integrated my AI agent (Bob’s Brain) with Slack, and it worked—sort of. Every time I sent a message, Bob responded six times with the exact same answer. The Cloudflare Tunnel logs showed constant timeout errors:

2025-10-09T08:12:20Z ERR Request failed error="Incoming request ended abruptly: context canceled"

This wasn’t a “minor bug”—this was a production-breaking issue that made the integration unusable.

The Journey: What Actually Happened

Starting Point: Unstable Tunnels

Before we even got to Slack, we had tunnel stability issues:

Applying Universal Directory Standards to a Prompt Engineering Repository

Wed, 08 Oct 2025 23:30:00 -0600

The Problem: Inconsistent File Naming Across Master Systems

I had a prompt engineering repository with 150+ templates organized in a logical category structure, but the 000-master-systems/ directory had inconsistent file naming. Some files used CATEGORY-###-description-MMDDYY.md, others didn’t. I needed to apply universal directory standards without breaking the existing structure.

The repository: prompts-intent-solutions

The Challenge: Two Different Naming Conventions

Here’s where it got interesting. I initially thought the pattern was:

CATEGORY-###-description-MMDDYY.md

Looking at existing files in 000-master-systems/github/:

Building Production-Grade Testing Infrastructure: A Playwright + GitHub Actions Case Study

Wed, 08 Oct 2025 14:30:00 -0600

The Challenge: Production-Grade Quality Assurance

When building the HUSTLE survey system - a 15-section survey with Netlify Forms integration, automated email notifications, and production deployment - the critical question emerged: How do you guarantee reliability for every user interaction?

This is the story of implementing production-grade testing infrastructure in a single focused session, including the debugging journey and architectural decisions that shaped the final solution.

What I Built: Complete Testing Architecture

Core Infrastructure

Playwright Testing Framework with:

Making a Youth Sports App COPPA-Compliant: The Real Process From Question to Production

Wed, 08 Oct 2025 14:30:00 -0600

When you’re building an app for tracking youth athlete statistics, legal compliance isn’t optional - it’s foundational. This is the complete story of implementing Terms of Service, Privacy Policy, and consent tracking, including all the troubleshooting, database migration failures, and UX decisions along the way.

From GitHub Repos to Published Education: Transforming Hidden Documentation into 31KB of Live Content

Tue, 07 Oct 2025 21:45:00 -0500

From GitHub Repos to Published Education: Transforming Hidden Documentation

The Problem: Your best educational content is trapped in project README files and documentation folders, invisible to your audience.

The Solution: Systematic content mining and transformation that turned two buried documentation projects into comprehensive published guides.

The Result: 31KB of premium educational content now live, featuring a cost optimization guide worth $474/month in savings and a complete Terraform curriculum.

The Discovery Phase

While working on the StartAITools educational platform, we realized a critical gap: comprehensive technical guides we’d written for internal projects weren’t published or discoverable.

When Your Best Work is Invisible: Mining 31KB of Education from My Own Projects

Tue, 07 Oct 2025 21:45:00 -0500

When Your Best Work is Invisible

I spent three hours today realizing I’m an idiot.

Not because I did something wrong. Because I did something right—twice—and then completely forgot to tell anyone about it.

The Embarrassing Discovery

“Hey, where’s the Hybrid AI Stack stuff on the blog?” a potential client asked. “And that Terraform guide you mentioned?”

I froze. “Oh, those are in the project repos… let me send you links…”

Terraform for AI Infrastructure: Complete Learning Guide from Zero to Production

Tue, 07 Oct 2025 17:00:00 -0500

Terraform for AI Infrastructure: Complete Learning Guide

TL;DR: Learn Infrastructure as Code with Terraform from beginner to advanced. Covers core concepts, state management, modules, best practices, and production deployment patterns for AI infrastructure.

What is Terraform?

Terraform is an Infrastructure as Code (IaC) tool that lets you define and provision cloud infrastructure using declarative configuration files instead of manual clicking in web consoles.

Key Benefits

Declarative Configuration: Describe what you want, not how to get there
Plan Before Apply: Preview all changes before execution
Version Control: Track infrastructure changes in Git
Multi-Cloud: Works with AWS, GCP, Azure, and 100+ providers
Idempotent: Safe to run multiple times without side effects

How It Works

1. Write Configuration (.tf files)
 ↓
2. terraform init (Download providers)
 ↓
3. terraform plan (Preview changes)
 ↓
4. terraform apply (Execute changes)
 ↓
5. Infrastructure Created/Updated

Core Concepts

1. Providers

Providers are plugins that interact with cloud platform APIs:

Hybrid AI Stack: Reduce AI API Costs by 60-80% with Intelligent Request Routing

Tue, 07 Oct 2025 16:30:00 -0500

Hybrid AI Stack: Reduce AI API Costs by 60-80% with Intelligent Request Routing

TL;DR: Run lightweight LLMs locally on CPU for simple tasks, use cloud APIs only for complex requests. Save 60-80% on AI costs while maintaining quality. Production-ready Docker stack with full monitoring.

The Problem

AI API costs add up fast:

Simple question: $0.0009 per request
Medium explanation: $0.0036 per request
Complex code generation: $0.0159 per request

At 200,000 requests/month, you’re paying $774/month for cloud-only AI.

Self-Hosting n8n on Contabo VPS: Enterprise Automation for $0/Month

Sat, 04 Oct 2025 00:00:00 +0000

We just deployed a production-ready n8n instance at n8n.intentsolutions.io with zero monthly software costs. Here’s the complete technical architecture and deployment process.

The Business Case

Before: Paying $20+/month for n8n Cloud After: $0/month on existing Contabo VPS Setup Time: 2 hours ROI: Infinite (one-time setup, zero recurring cost)

Architecture Overview

┌─────────────────────────────────────┐
│ n8n.intentsolutions.io (DNS) │
│ ↓ │
│ 194.113.67.242:443 (HTTPS) │
│ ↓ │
│ Caddy Reverse Proxy │
│ - Auto SSL (Let's Encrypt) │
│ - Port 443 (HTTPS) │
│ ↓ │
│ Docker Container: n8n │
│ - Port 5678 (internal) │
│ - SQLite database │
│ - Persistent data: ./data │
│ - Backups: ./backups │
└─────────────────────────────────────┘

Technical Challenge: Port Conflicts

The server was already running:

Building a Multi-Brand RSS Validation System: Testing 97 Feeds, Learning Hard Lessons

Fri, 03 Oct 2025 17:30:00 -0600

The Problem: Building Content Distribution Without Data Validation

Here’s a mistake I made this week: I proposed 33 RSS feeds for an automated content distribution system without testing a single one first.

The user’s response? “did u try the new feeds to ensure they match criteria for tier 1”

Ouch. But also - absolutely correct. What’s the point of designing an elegant multi-brand content routing system if half your data sources are broken?

GitHub Release Workflow: When Yesterday's Updates Aren't Public (And How We Fixed It)

Fri, 03 Oct 2025 11:47:00 -0600

The Question That Started Everything

“Can u make sure the updates for applied to the publix repo let me know if they did ir didnt then i will tell u ehag i need”

It’s a straightforward question - are yesterday’s slash command fixes public? But the answer revealed a complete chain of uncommitted work sitting in a local branch, waiting to be released. This is the story of taking local improvements and turning them into a proper public release with semantic versioning.

Debugging Claude Code Slash Commands: When Your Blog Automation Silently Fails

Fri, 03 Oct 2025 01:15:00 -0600

The Mystery: Content Created, But Never Published

You ever have one of those debugging sessions where the problem seems impossible? The code works. The files are created. But… nothing shows up in production. That was my morning.

My custom Claude Code slash commands (/blog-startaitools, /blog-single-startai) were supposedly working. Claude would generate excellent blog posts, create the markdown files, run Hugo builds successfully, and claim everything was deployed. But when I checked startaitools.com? Nothing. The posts weren’t there.

Repository Transformation: From Chaos to Professional Prompt Engineering Toolkit

Thu, 02 Oct 2025 08:00:00 -0500

Executive Summary

The Prompts Intent Solutions repository transformation demonstrates how to evolve a good prompt collection into a professional-quality toolkit. This comprehensive guide documents the complete journey: from scattered files and inconsistent naming to a battle-tested system with 150+ organized templates, 74 Claude Code agents, and automated validation.

Transformation Results:

🏗️ Structure: Complete reorganization of 150+ prompt templates
🧹 Cleanup: Removed date suffixes from all filenames for cleaner navigation
📁 Organization: Moved 25+ shell scripts from root to organized subdirectories
🌐 Presentation: Professional GitHub Pages site with monospace design
🤖 Integration: 74 Claude Code agent configurations prominently featured
✅ Quality: Automated validation system with CI/CD pipeline

The Challenge: When Good Intentions Create Chaos

The Starting Point

Our prompt engineering repository had grown organically over months, accumulating:

DevOps Onboarding at Scale: Creating Comprehensive System Analysis with Universal Templates

Wed, 01 Oct 2025 16:30:00 -0600

DevOps Onboarding at Scale: Creating Comprehensive System Analysis with Universal Templates

When you’re bringing a new team member onto a complex multi-project platform, the difference between success and confusion often comes down to documentation quality and access setup. Today I’m sharing the complete journey of onboarding Opeyemi Ariyo as Senior Cybersecurity Engineer to the DiagnosticPro platform - from creating comprehensive system analysis to solving real-world GCP permission challenges.

The Challenge: Multi-Project Architecture Complexity

The DiagnosticPro platform isn’t just one application - it’s a sophisticated ecosystem spanning:

Leading Complex System Onboarding: From Documentation to Infrastructure Access

Wed, 01 Oct 2025 16:45:00 -0500

When you’re responsible for bringing a new senior team member onto a complex platform spanning multiple GCP projects, hundreds of database tables, and interconnected services, the quality of your onboarding process becomes a direct reflection of your technical leadership capabilities.

Today I want to share how I approached onboarding Opeyemi Ariyo as Senior Cybersecurity Engineer to the DiagnosticPro platform - not just the technical work, but the leadership thinking and systematic problem-solving that made it successful.

Enterprise Documentation Transformation: Git-Native TaskWarrior Workflows for Platform Reorganization

Tue, 30 Sep 2025 16:30:00 -0500

A technical deep-dive into enterprise platform reorganization using systematic documentation, TaskWarrior CLI integration, and git-native workflows. Learn how to safely transform production systems with zero downtime.

AI-Assisted Technical Writing: From Case Study to Published Portfolio in 30 Minutes

Tue, 30 Sep 2025 16:00:00 -0400

2025-09-30 16:00:00

Transforming Technical Work into Professional Portfolio Content: A Complete AI-Assisted Workflow

Ever wondered how to efficiently transform complex technical work into compelling portfolio content? This post documents a real AI-assisted workflow that took a comprehensive platform reorganization project and turned it into a professional case study, published to a career blog in under 30 minutes.

What We’ll Cover:

Real-world AI-assisted technical writing workflow
Multi-agent collaboration for content quality
Automated blog publishing with Hugo/Netlify
Professional portfolio development strategies
Practical implementation guide for developers

The Challenge: Technical Work → Professional Narrative

The scenario: Jeremy completed a massive DiagnosticPro platform reorganization project involving:

Building AI-Friendly Codebase Documentation: A Real-Time CLAUDE.md Creation Journey

Sun, 28 Sep 2025 20:30:00 -0600

Building AI-Friendly Codebase Documentation: A Real-Time CLAUDE.md Creation Journey

Have you ever wondered what happens when an AI needs to understand your codebase from scratch? Today I’m sharing exactly that process - how Claude Code analyzed my analytics repository and created comprehensive project documentation in real-time.

The Context: A Complex Analytics System

I was working in my /home/jeremy/analytics directory when I ran the /init command in Claude Code. This command tells Claude to analyze the codebase and create a CLAUDE.md file that will help future instances work effectively with the project.

Enterprise Software Transformation: From Framework to Production Server - A Project Management Case Study

Sun, 28 Sep 2025 20:50:00 -0500

How do you transform a foundational software framework into an enterprise-grade production server? Through systematic analysis, professional project management, and methodical execution.

This case study demonstrates my approach to complex software transformation projects, showcasing the methodology I use to tackle enterprise-level challenges with professional project management tools and systematic problem-solving.

The Challenge: Complex Software Transformation

Project: Waygate MCP Enterprise Server Development Scope: Transform foundational MCP framework into production-ready enterprise server Timeline: Single intensive development session Methodology: Forensic analysis with TaskWarrior project management

Transforming Complex N8N Workflows: From Analysis to Enterprise Tech Intelligence Platform

Sun, 28 Sep 2025 19:30:00 -0500

How I Transformed a Complex N8N Workflow Into an Enterprise Tech Intelligence Platform

When a client asked me to “analyze their N8N workflow,” I discovered a sophisticated 35KB automation system disguised as a simple RSS reader. What followed was a complete enterprise transformation that demonstrates my approach to complex technical projects.

Project Overview: Beyond Surface-Level Analysis

Challenge: Analyze and improve an N8N news workflow Discovery: Enterprise-grade system with poor documentation Solution: Complete transformation into tech intelligence platform Impact: 150% improvement in relevance, professional documentation suite

When a Simple Security Audit Turns Into a 3-Hour Python Environment Battle (And How We Won)

Sun, 28 Sep 2025 18:10:00 -0500

Ever have one of those days where you start with a simple task and end up questioning your entire technical setup? That was my Saturday morning when what should have been a ‘quick security audit’ turned into a full-scale infrastructure overhaul.

Waygate MCP v2.1.0: From Forensic Analysis to Production Enterprise Server with TaskWarrior

Sun, 28 Sep 2025 14:50:00 -0600

What happens when you run a ‘forensic-level MCP repository diagnostic with TaskWarrior project management’? You get a complete transformation from foundational framework to enterprise-grade production server. Here’s the complete technical journey.

Building Multi-Platform Developer Tools: Scaling an Open-Source Project from 1 to 5 Platforms

Sat, 27 Sep 2025 19:30:00 -0500

The Challenge

Yesterday I open-sourced Claude AutoBlog SlashCommands - a tool that automates blog publishing for developers. Within hours, I got feedback: “Can you make this work for platforms beyond just Hugo?”

The request revealed a classic software design challenge: How do you scale a specialized tool to serve diverse use cases without losing simplicity?

The Approach

Rather than rewrite the original commands for each platform, I identified what made them valuable:

Automating Developer Workflows: Building Custom AI Command Systems

Sat, 27 Sep 2025 16:45:00 -0500

Building custom automation tools that transform how developers document and share their work. Today’s project: creating intelligent slash commands that analyze project context and generate technical content automatically.

The Challenge

Professional developers face a consistent challenge: maintaining quality documentation while staying productive. Technical blog posts that showcase expertise often get deprioritized because writing them requires:

Reconstructing context after the work is complete
Manually reviewing git histories and code changes
Finding relevant cross-references to existing content
Managing the entire publishing workflow

The friction between development work and documentation creates a gap where valuable insights go unshared.

From Chaos to One-Paste Magic Part 4: Dual AI Workflows — Claude Meets Cursor

Wed, 17 Sep 2025 03:45:00 -0600

Once the repo was simplified and the 22-document suite completed, the next step was distribution. How could developers actually use this without friction?

The answer came in two flavors: Claude Code CLI for the copy-paste crowd, and Cursor IDE for structured devs who like guardrails.

But more importantly, this dual approach revealed something bigger — we’re entering a new era of software development.

What We Built

🅰️ Claude Path (One-Paste Magic)

For the “I need it yesterday” developers:

From Chaos to One-Paste Magic Part 3: From Templates to One-Paste Magic

Wed, 17 Sep 2025 03:40:00 -0600

In the first two parts of this series, we took the repo from a messy, complex setup into a clean foundation with 22 enterprise-grade documents. Now, we flip the switch: this repo isn’t just a library of templates anymore — it’s a working AI-powered documentation pipeline.

With one paste in Claude Code CLI, or a structured workflow in Cursor IDE, anyone can generate a complete enterprise documentation suite in minutes. No Docker. No BMAD. No friction.

From Chaos to One-Paste Magic Part 2: Evolving Templates into an Enterprise Library

Wed, 17 Sep 2025 03:35:00 -0600

In Part 1, I walked through how messy the repo had become and how I normalized everything. But cleanup was just the start. The real milestone came when I took @ryancarson’s excellent template foundation and evolved it into a 22-document enterprise-grade library that any CTO would be happy to run their teams on.

From 4 to 22 Templates

The original templates from @ryancarson — PRD, ADR, Generate Tasks, and Process Task List — were already powerful. They provided a structured backbone for planning and communication that was miles ahead of most documentation practices I’d seen.

From Chaos to One-Paste Magic Part 1: The Mess (and Why It Mattered)

Wed, 17 Sep 2025 03:30:00 -0600

If you’ve ever inherited a repo that felt like a haunted house — you open a folder and something jumps out at you (Docker configs, half-broken YAML, strange bmad-output-00.md files) — then you’ll know how I felt walking into my own AI-Dev workspace.

The Starting Point: Beautiful Chaos

What started as an experiment with BMAD-METHOD™ (a 42k-line, multi-agent beast) and some rough starter templates quickly spiraled into something that would make even the most battle-hardened developer wince:

The Evolution of a Development Machine: 20 Days from Ubuntu Install to Production Powerhouse

Sun, 14 Sep 2025 03:30:00 -0500

The Journey: From Fresh Ubuntu to Full-Stack Development Environment

Today I want to share the incredible 20-day evolution of my Ubuntu development machine. Using file timestamps and git history, I’ve reconstructed the exact timeline of how a fresh Linux install became a production powerhouse running multiple SaaS projects, processing millions of data points, and generating content automatically.

Day 0: August 25, 2025 - The Beginning

5:00 PM: Fresh Ubuntu installation

🚀 The Complete AI Engineering Curriculum: From Zero to $200K+ Salary

Sat, 13 Sep 2025 12:00:00 +0000

The AI Engineering Revolution Is Here - And You’re Invited 🎯

The numbers are insane:

$206,000 - Average AI Engineer salary (up $50K from last year)
24,000+ - Open positions RIGHT NOW
90% - Code at leading companies is now AI-generated
18.7% - Salary premium over non-AI roles

The problem? Only 2.5% of these positions are entry-level.

That’s why I’ve created something special…

Originally inspired by Zach Wilson (@eczachly)’s X post on AI Engineering levels

What I'm Discovering About Marketing Automation Pricing Challenges

Fri, 12 Sep 2025 00:00:00 +0000

What I’m Discovering About Marketing Automation Pricing Challenges

Through my work with various agencies and consultants in the marketing automation space, I’ve been uncovering some fascinating patterns around pricing struggles that seem to be industry-wide. These aren’t my personal challenges—my business is doing well—but I’m seeing these issues repeatedly across the consultant community.

This is market research and pattern recognition, not personal business struggles. I’m documenting what I’m discovering because these patterns affect the entire industry.

DiagnosticPro: Revolutionary Feature Rollouts Coming This Quarter

Thu, 11 Sep 2025 00:45:00 -0500

Timestamp: 2025-09-11 15:45:00

Major Platform Evolution: Beyond Traditional Diagnostics

We’re about to revolutionize how people diagnose equipment problems. While everyone else is still stuck with basic text forms and single photos, DiagnosticPro is launching the most comprehensive diagnostic media platform ever built.

Here’s what’s rolling out this quarter:

🎥 Industry-First Video Diagnostics

The Game Changer: Full video recording with synchronized audio - think Loom meets professional equipment diagnostics.

Why This Matters:

DiagnosticPro Evolution: From Database Concept to $29.99 AI Platform - A Complete Project Autopsy

Wed, 10 Sep 2025 15:00:00 -0500

Project Forensics: The Complete DiagnosticPro Evolution

What happens when you perform a complete forensic analysis of a project’s evolution from concept to production? You discover the true DNA of innovation - the messy, iterative, brilliant journey from idea to revenue-generating platform.

I just completed an exhaustive analysis of 13,597 files across five distinct evolutionary stages of DiagnosticPro, and the story that emerged is fascinating.

The Evolution Timeline: Legacy → MVP3-B

Stage 1: Legacy - The Genesis (1 file)

“Every empire starts with a single brick”

Building a 254-Table BigQuery Schema in 72 Hours

Mon, 08 Sep 2025 14:30:00 -0500

The Challenge: Zero to Production in 72 Hours

In January 2025, we faced an ambitious challenge: build a production-ready data platform capable of ingesting, processing, and storing diagnostic data from multiple sources at massive scale. The requirements were clear but daunting:

254+ production tables in BigQuery
Multiple data sources: YouTube API, Reddit (PRAW), GitHub repositories, RSS feeds
Real-time processing with sub-100ms validation
10,000 records/second bulk import capability
Complete separation of concerns between data collection and storage
72-hour deadline for production deployment

What followed was an intense sprint of architectural design, rapid prototyping, and systematic deployment that resulted in a fully operational BigQuery data warehouse now running as diagnostic-pro-start-up on Google Cloud Platform.

N8N Workflow Automation: Building Enterprise Automation Without Code

Mon, 08 Sep 2025 14:30:00 -0500

Executive Summary

N8N workflow automation transforms businesses by eliminating manual tasks, reducing errors, and enabling 24/7 operations. This comprehensive guide demonstrates how organizations achieve 80% reduction in manual work and 24/7 automated operations using N8N’s powerful no-code platform.

Key Business Impact:

🚀 Productivity: 80% reduction in manual tasks
⏰ Operations: 24/7 automated business processes
💰 Cost Savings: 65% reduction in operational overhead
📊 Accuracy: 95% error reduction through automation
⚡ Speed: 10x faster task completion

What is N8N? The Enterprise Automation Revolution

N8N (pronounced “n-eight-n”) is an open-source workflow automation platform that connects your business tools, automates repetitive tasks, and orchestrates complex business processes - all without writing a single line of code.

Start AI Tools: Rapid AI Implementation Platform

Mon, 08 Sep 2025 14:00:00 -0500

Executive Summary

Start AI Tools represents the evolution of AI implementation - transforming complex AI integration from months-long projects into rapid, day-one deployments. Built as both a showcase platform and service delivery system, it demonstrates how modern development practices can deliver enterprise-grade AI solutions at unprecedented speed.

Platform Highlights:

🚀 Launch Speed: Built and deployed in less than 24 hours
🎯 Focus: Rapid AI implementation for real business problems
🌊 Location: Gulf Shores, Alabama with global service delivery
🔗 Integration: Part of Intent Solutions Inc ecosystem
💼 Methodology: Proven rapid deployment framework

Live Platform: startaitools.com

Building DiagnosticPro: AI-Powered Vehicle Diagnostics Platform

Mon, 08 Sep 2025 12:00:00 -0500

Executive Summary

DiagnosticPro represents a paradigm shift in vehicle diagnostics - transforming complex professional-grade analysis into accessible, AI-powered insights. Built in days, not months, this platform demonstrates how modern AI and cloud infrastructure can rapidly deliver enterprise-scale solutions.

Key Metrics:

🚀 Launch Time: 4 days from concept to production
📊 Scale: 254+ BigQuery tables processing multi-source data
🔍 Data Sources: 226+ RSS feeds, YouTube, Reddit, GitHub
💰 Pricing: $29.99 per comprehensive diagnostic
🤖 AI Engine: GPT-4 powered analysis with context awareness

The Challenge: Democratizing Professional Diagnostics

Vehicle diagnostics has long been the domain of expensive professional equipment and specialized knowledge. Mechanics invest thousands in diagnostic tools, while car owners face uncertainty about repair costs and technical accuracy.

Distributed Systems Architecture Patterns Cheat Sheet

Mon, 13 Jan 2025 15:45:00 -0600

A quick reference guide for distributed systems architecture patterns, covering when to use each pattern and the classic problems they solve.

Distributed Systems Architecture Patterns Cheat Sheet
#

Pattern	Core Idea	When to Use	Classic Problems
Caching (cache-aside / write-through / write-back)	Keep hot data close to the app	Read-heavy workloads, expensive queries, slow upstreams	Speed up product pages, session stores, ranking feeds
CDN	Push static/streamable assets to edge	Global users, large media, static bundles	Image/CSS delivery, video streaming, downloads
Load Balancing (L4/L7)	Spread traffic across instances	Scale stateless services, HA	Web/API tier scaling, zero-downtime deploys
Rate Limiting & Throttling	Control request volume per key/client	Protect downstream services, fair usage	Public APIs, login abuse protection
Circuit Breaker	Fail fast when a dependency is unhealthy	Prevent cascades, degrade gracefully	Payment gateway outage, flaky search backend
Backpressure	Signal producers to slow down	Spiky traffic, limited consumers	Upload pipelines, stream processing stability
Retry + Idempotency	Safe replays of failed ops	Unreliable networks, async workflows	Order creation, webhook delivery
Read Replicas	Offload reads from primary DB	Read-heavy, reporting, geo-reads	Analytics pages, timelines, leaderboards
Sharding (Hash/Range/Geo)	Split data across nodes	Data > single node, parallelism	Multi-TB user tables, geo data stores
Replication (Sync/Async)	Keep copies for HA & reads	Availability, DR, low-latency reads	Active-passive failover, follower reads
CQRS	Separate read/write models	Complex reads + high write throughput	Event feeds, denormalized dashboards
Event Sourcing	State = log of events	Full audit, rebuild state, temporal queries	Ledger systems, order state timelines
Message Queue / Stream (SQS/Kafka)	Async decoupling via durable logs	Spikes, fan-out, ordered pipelines	Email/SMS, ETL, clickstream processing
Saga (Orchestration/Choreography)	Distributed transaction via steps + compensation	Cross-service workflows without 2PC	Book-pay-reserve flows, refunds
Search Index (ES/OpenSearch)	Inverted index for fast text/filters	Full-text, aggregations, relevance	Product search, logs explorer
Time-Series DB	Append-heavy metrics optimized by time	Monitoring, IoT, financial ticks	Prometheus/TSDB, sensor data
Write-Optimized Stores (LSM)	Fast writes, compaction later	High ingest, occasional reads	Audit/event logs, analytics ingest
Geo-Replication / Geo-Sharding	Place data near users	Low latency, data residency	Multi-region apps, GDPR residency
Consistency Models (Strong/Eventual)	Pick latency vs guarantees	Cross-region apps, offline tolerance	Cart totals vs likes counters
API Gateway	Central entry: auth, routing, limits	Many services, uniform policies	Public API front door, mTLS termination
Webhooks & Outboxes	Reliable external notifications	Integrations, third-party callbacks	Payment status updates, CRM sync
Blob/Object Storage	Cheap infinite files	Media, backups, exports	User uploads, data lakes
Workflow Orchestrator (Airflow/Temporal)	Durable, reliable step with state	Long-running jobs, SLAs	Report generation, video pipelines
Blue-Green / Canary Deploys	Shift traffic gradually	Safer releases, quick rollback	API rollout, config changes
Feature Flags	Runtime on/off % rollouts	Experimentation, kill-switches	A/B tests, dark launches
Schema Migration Strategy	Backward-/forward-compatible changes	Zero-downtime DB upgrades	Expand-migrate-contract patterns
Distributed Locks / Leader Election	Coordinate one active worker	Cron uniqueness, shared ownership	Single consumer, partition leader
Observability (Logs/Metrics/Traces)	See what the system is doing	SLOs, debugging, capacity planning	P99 latency, error budgets, trace trees
Security: AuthN/AuthZ	Verify identity and permissions	Multi-tenant products, external APIs	OAuth2/OIDC, RBAC/ABAC
Multi-Tenancy (Pool/Bridge/Isolated)	Resource & data isolation levels	SaaS with many customers	Per-tenant DBs vs shared schema
Edge Compute / Functions	Run logic near the user	Latency-sensitive, light workloads	Personalization at edge, AB tests
Rate-Aware DB Patterns	Batch, queue, throttle at DB edge	Hot partitions, lock contention	Bulk imports, ID sequence hot-spot
Pagination Strategies	Keyset + Offset for big data	Infinite scroll, large tables	Feed pagination, admin lists

How to Use This Cheat Sheet
#

Comprehensive Technical Guide to SSH, Debian Packages, and Grep

Mon, 13 Jan 2025 10:00:00 -0600

This comprehensive technical guide was developed with assistance from ScholarGPT and GPT-5, providing graduate-level coverage of essential Linux administration tools.

üîêüì¶üîç Comprehensive Technical Guide to SSH, Debian Packages, and Grep
#

Table of Contents
#

Introduction
Secure Shell (SSH)
- Core Concepts
- Basic Usage
- Authentication Methods
- Advanced Features
- Configuration Files
- Security Best Practices
- Troubleshooting
- Exercises
Debian Package Management (.deb)
- Understanding Debian Packages
- Core Tools (dpkg & APT)
- Installing & Removing Packages
- Dependency Management
- Building Debian Packages
- Repositories & Configuration
- Security Considerations
- Troubleshooting
- Exercises
Text Processing with grep
- Core Concepts
- Basic Syntax & Usage
- Regular Expressions
- Advanced Patterns & Options
- Performance Considerations
- Integration with Other Tools
- Troubleshooting
- Exercises
Cross-Integration of SSH, .deb, and grep
Conclusion & Further Resources

Introduction
#

Production Release Engineering: Shipping v4.5.0 with 739 Skills and Zero Downtime

Fri, 03 Jan 2025 22:55:00 -0600

The Challenge

I needed to ship v4.5.0 of the Claude Code Plugins marketplace after 8 days of intensive development. The release included:

38 commits across multiple feature areas
500 new standalone skills (739 total)
ZCF Integration (5 phases complete)
External Plugin Sync infrastructure
MCP Registry manifests for 7 servers
5,385 files changed (+197K lines, -8K lines)

The requirement: Zero manual errors, complete audit trail, automated quality gates, and the ability to roll back at any failure point.

Research & Curriculum

Mon, 01 Jan 2001 00:00:00 +0000

AI Engineering Curriculum & Technical Papers

Welcome to our research collection featuring academic papers, technical studies, and in-depth analysis in AI development and systems architecture.

Featured Research

AI Development & Engineering

NLWeb: Building the AI Web with Natural Language Interfaces - Microsoft’s open-source framework for building conversational interfaces using MCP and Schema.org standards
Agentic Context Engineering: Evolving Contexts for Self-Improving LMs - Stanford/Princeton research on ACE framework treating AI contexts as evolving playbooks (+10.6% agent performance, +8.6% finance tasks)
Tiny Recursive Models: Less is More - Samsung research achieving 45% on ARC-AGI-1 with only 7M parameters through recursive reasoning
Model Context Protocol (MCP) for Beginners - Comprehensive Microsoft curriculum with hands-on labs in C#, Java, JavaScript, Rust, Python, and TypeScript
Hybrid AI Stack: Reduce AI Costs by 60-80% - Production-ready system that intelligently routes between local CPU models and cloud APIs to slash costs
Complete AI Engineering Curriculum - Comprehensive guide from zero to $200K+ AI engineering salary
Multi-Agent Architecture - Exploring distributed AI system design patterns
Scaling AI Inference to Billions - Google Cloud’s decade-long journey in AI infrastructure
Bob’s Brain: Open Source AI Assistant - Slack AI assistant template with enterprise integration
Imbalanced-learn ML Toolkit - Essential toolkit for handling imbalanced datasets

Systems Architecture & Patterns

Terraform for AI Infrastructure: Complete Guide - From zero to production: comprehensive Terraform learning resource for AI and cloud infrastructure
Distributed Systems Architecture Patterns - Comprehensive cheat sheet for scalable system design
Modern AI Transformer Deployment - End-to-end guide for production AI model serving

Platform Engineering Case Studies

Building 254-Table BigQuery Schema in 72 Hours - Enterprise data platform architecture with 254 BigQuery tables
DiagnosticPro Evolution Analysis - Complete forensic analysis of 13,597 files in AI platform development
DiagnosticPro Platform Case Study - AI-powered vehicle diagnostics platform
Building DiagnosticPro Platform - Complete technical breakdown of AI diagnostic system
DiagnosticPro Feature Rollouts - Preview of advanced AI diagnostic features
From Zero to AI Empire - Complete project evolution timeline and architecture decisions
Season 2025 Recap - Complete year overview of platform development

Developer Tools & Documentation

AI-Dev Transformation Part 1 - From chaos to organized AI-powered development
AI-Dev Transformation Part 2 - Building enterprise prompt libraries
AI-Dev Transformation Part 3 - One-paste magic template system
AI-Dev Transformation Part 4 - Dual AI workflows with Claude and Cursor
Building AI-Friendly Documentation - Professional documentation toolkit with Claude
Repository Transformation Guide - From chaos to professional prompt engineering toolkit

Security & Linux Systems

Advanced Linux Security - SSH, Debian package management, and security best practices
Comprehensive SSH, Debian & Grep Guide - Technical guide to SSH, Debian packages, and text processing
Linux Security Glossary - Comprehensive reference for systems administration
Security Audit & Python Environment Battle - 3-hour battle with Python environments and security audits
Waygate MCP v2.1.0 Production Release - Enterprise MCP server with TaskWarrior

Founder’s Journey & Development Insights

Founder’s Log: September 2025 - Daily operations and strategic thinking in AI platform development
Day One Tech Journey - Starting the AI engineering journey
A Day of Steel Beams and Soccer - Balancing life and tech
The Perfect Developer Workspace - Lessons from a real-world cleanup

Methodology & Tools

Our research methodology emphasizes:

Mon, 01 Jan 0001 00:00:00 +0000

Introduction to Model Context Protocol (MCP): Why It Matters for Scalable AI Applications

(Click the image above to view video of this lesson)

Generative AI applications are a great step forward as they often let the user interact with the app using natural language prompts. However, as more time and resources are invested in such apps, you want to make sure you can easily integrate functionalities and resources in such a way that it’s easy to extend, that your app can cater to more than one model being used, and handle various model intricacies. In short, building Gen AI apps is easy to begin with, but as they grow and become more complex, you need to start defining an architecture and will likely need to rely on a standard to ensure your apps are built in a consistent way. This is where MCP comes in to organize things and provide a standard.

Mon, 01 Jan 0001 00:00:00 +0000

MCP Core Concepts: Mastering the Model Context Protocol for AI Integration

(Click the image above to view video of this lesson)

The Model Context Protocol (MCP) is a powerful, standardized framework that optimizes communication between Large Language Models (LLMs) and external tools, applications, and data sources. This guide will walk you through the core concepts of MCP. You will learn about its client-server architecture, essential components, communication mechanics, and implementation best practices.

Mon, 01 Jan 0001 00:00:00 +0000

MCP Security: Comprehensive Protection for AI Systems

(Click the image above to view video of this lesson)

Security is fundamental to AI system design, which is why we prioritize it as our second section. This aligns with Microsoft’s Secure by Design principle from the Secure Future Initiative.

The Model Context Protocol (MCP) brings powerful new capabilities to AI-driven applications while introducing unique security challenges that extend beyond traditional software risks. MCP systems face both established security concerns (secure coding, least privilege, supply chain security) and new AI-specific threats including prompt injection, tool poisoning, session hijacking, confused deputy attacks, token passthrough vulnerabilities, and dynamic capability modification.

Mon, 01 Jan 0001 00:00:00 +0000

Getting Started

(Click the image above to view video of this lesson)

This section consists of several lessons:

1 Your first server, in this first lesson, you will learn how to create your first server and inspect it with the inspector tool, a valuable way to test and debug your server, to the lesson
2 Client, in this lesson, you will learn how to write a client that can connect to your server, to the lesson

Mon, 01 Jan 0001 00:00:00 +0000

Practical Implementation

(Click the image above to view video of this lesson)

Practical implementation is where the power of the Model Context Protocol (MCP) becomes tangible. While understanding the theory and architecture behind MCP is important, the real value emerges when you apply these concepts to build, test, and deploy solutions that solve real-world problems. This chapter bridges the gap between conceptual knowledge and hands-on development, guiding you through the process of bringing MCP-based applications to life.

Mon, 01 Jan 0001 00:00:00 +0000

Advanced Topics in MCP

(Click the image above to view video of this lesson)

This chapter covers a series of advanced topics in Model Context Protocol (MCP) implementation, including multi-modal integration, scalability, security best practices, and enterprise integration. These topics are crucial for building robust and production-ready MCP applications that can meet the demands of modern AI systems.

Overview

This lesson explores advanced concepts in Model Context Protocol implementation, focusing on multi-modal integration, scalability, security best practices, and enterprise integration. These topics are essential for building production-grade MCP applications that can handle complex requirements in enterprise environments.

Mon, 01 Jan 0001 00:00:00 +0000

Community and Contributions

(Click the image above to view video of this lesson)

Overview

This lesson focuses on how to engage with the MCP community, contribute to the MCP ecosystem, and follow best practices for collaborative development. Understanding how to participate in open-source MCP projects is essential for those looking to shape the future of this technology.

Learning Objectives

By the end of this lesson, you will be able to:

Mon, 01 Jan 0001 00:00:00 +0000

🌟 Lessons from Early Adopters

(Click the image above to view video of this lesson)

🎯 What This Module Covers

This module explores how real organizations and developers are leveraging the Model Context Protocol (MCP) to solve actual challenges and drive innovation. Through detailed case studies, hands-on projects### Case Study 5: Azure MCP – Enterprise-Grade Model Context Protocol as a Service

Azure MCP (https://aka.ms/azmcp) is Microsoft’s managed, enterprise-grade implementation of the Model Context Protocol, designed to provide scalable, secure, and compliant MCP server capabilities as a cloud service. This comprehensive suite includes multiple specialized MCP servers for different Azure services and scenarios.

Mon, 01 Jan 0001 00:00:00 +0000

MCP Development Best Practices

(Click the image above to view video of this lesson)

Overview

This lesson focuses on advanced best practices for developing, testing, and deploying MCP servers and features in production environments. As MCP ecosystems grow in complexity and importance, following established patterns ensures reliability, maintainability, and interoperability. This lesson consolidates practical wisdom gained from real-world MCP implementations to guide you in creating robust, efficient servers with effective resources, prompts, and tools.

Mon, 01 Jan 0001 00:00:00 +0000

MCP in Action: Real-World Case Studies

(Click the image above to view video of this lesson)

The Model Context Protocol (MCP) is transforming how AI applications interact with data, tools, and services. This section presents real-world case studies that demonstrate practical applications of MCP in various enterprise scenarios.

Overview

This section showcases concrete examples of MCP implementations, highlighting how organizations are leveraging this protocol to solve complex business challenges. By examining these case studies, you’ll gain insights into the versatility, scalability, and practical benefits of MCP in real-world scenarios.

Mon, 01 Jan 0001 00:00:00 +0000

Streamlining AI Workflows: Building an MCP Server with AI Toolkit

🎯 Overview

(Click the image above to view video of this lesson)

Welcome to the Model Context Protocol (MCP) Workshop! This comprehensive hands-on workshop combines two cutting-edge technologies to revolutionize AI application development:

🔗 Model Context Protocol (MCP): An open standard for seamless AI-tool integration
🛠️ AI Toolkit for Visual Studio Code (AITK): Microsoft’s powerful AI development extension

🎓 What You’ll Learn

By the end of this workshop, you’ll master the art of building intelligent applications that bridge AI models with real-world tools and services. From automated testing to custom API integrations, you’ll gain practical skills to solve complex business challenges.

Mon, 01 Jan 0001 00:00:00 +0000

🚀 MCP Server with PostgreSQL - Complete Learning Guide

🧠 Overview of the MCP Database Integration Learning Path

This comprehensive learning guide teaches you how to build production-ready Model Context Protocol (MCP) servers that integrate with databases through a practical retail analytics implementation. You’ll learn enterprise-grade patterns including Row Level Security (RLS), semantic search, Azure AI integration, and multi-tenant data access.

Whether you’re a backend developer, AI engineer, or data architect, this guide provides structured learning with real-world examples and hands-on exercises which walks you through the following MCP server https://github.com/microsoft/MCP-Server-and-PostgreSQL-Sample-Retail.

Mon, 01 Jan 0001 00:00:00 +0000

AGENTS.md

Project Overview

MCP for Beginners is an open-source educational curriculum for learning the Model Context Protocol (MCP) - a standardized framework for interactions between AI models and client applications. This repository provides comprehensive learning materials with hands-on code examples across multiple programming languages.

Key Technologies

Programming Languages: C#, Java, JavaScript, TypeScript, Python, Rust
Frameworks & SDKs:
- MCP SDK (@modelcontextprotocol/sdk)
- Spring Boot (Java)
- FastMCP (Python)
- LangChain4j (Java)
Databases: PostgreSQL with pgvector extension
Cloud Platforms: Azure (Container Apps, OpenAI, Content Safety, Application Insights)
Build Tools: npm, Maven, pip, Cargo
Documentation: Markdown with automated multi-language translation (48+ languages)

Architecture

11 Core Modules (00-11): Sequential learning path from fundamentals to advanced topics
Hands-on Labs: Practical exercises with complete solution code in multiple languages
Sample Projects: Working MCP server and client implementations
Translation System: Automated GitHub Actions workflow for multi-language support
Image Assets: Centralized images directory with translated versions

Setup Commands

This is a documentation-focused repository. Most setup occurs within individual sample projects and labs.

Mon, 01 Jan 0001 00:00:00 +0000

Changelog: MCP for Beginners Curriculum

This document serves as a record of all significant changes made to the Model Context Protocol (MCP) for Beginners curriculum. Changes are documented in reverse chronological order (newest changes first).

October 6, 2025

Getting Started Section Expansion – Advanced Server Usage & Simple Authentication

Advanced Server Usage (03-GettingStarted/10-advanced)

New Chapter Added: Introduced a comprehensive guide to advanced MCP server usage, covering both regular and low-level server architectures.
- Regular vs. Low-Level Server: Detailed comparison and code examples in Python and TypeScript for both approaches.
- Handler-Based Design: Explanation of handler-based tool/resource/prompt management for scalable, flexible server implementations.
- Practical Patterns: Real-world scenarios where low-level server patterns are beneficial for advanced features and architecture.

Simple Authentication (03-GettingStarted/11-simple-auth)

New Chapter Added: Step-by-step guide to implementing simple authentication in MCP servers.
- Auth Concepts: Clear explanation of authentication vs. authorization, and credential handling.
- Basic Auth Implementation: Middleware-based authentication patterns in Python (Starlette) and TypeScript (Express), with code samples.
- Progression to Advanced Security: Guidance on starting with simple auth and advancing to OAuth 2.1 and RBAC, with references to advanced security modules.

These additions provide practical, hands-on guidance for building more robust, secure, and flexible MCP server implementations, bridging foundational concepts with advanced production patterns.

Mon, 01 Jan 0001 00:00:00 +0000

Microsoft Open Source Code of Conduct

This project has adopted the Microsoft Open Source Code of Conduct.

Resources:

Microsoft Open Source Code of Conduct
Microsoft Code of Conduct FAQ
Contact opencode@microsoft.com with questions or concerns

Mon, 01 Jan 0001 00:00:00 +0000

Security

Microsoft takes the security of our software products and services seriously, which includes all source code repositories managed through our GitHub organizations, which include Microsoft, Azure, DotNet, AspNet and Xamarin.

If you believe you have found a security vulnerability in any Microsoft-owned repository that meets Microsoft’s definition of a security vulnerability, please report it to us as described below.

Reporting Security Issues

Please do not report security vulnerabilities through public GitHub issues.

Mon, 01 Jan 0001 00:00:00 +0000

Model Context Protocol (MCP) for Beginners - Study Guide

This study guide provides an overview of the repository structure and content for the “Model Context Protocol (MCP) for Beginners” curriculum. Use this guide to navigate the repository efficiently and make the most of the available resources.

Repository Overview

The Model Context Protocol (MCP) is a standardized framework for interactions between AI models and client applications. Initially created by Anthropic, MCP is now maintained by the broader MCP community through the official GitHub organization. This repository provides a comprehensive curriculum with hands-on code examples in C#, Java, JavaScript, Python, and TypeScript, designed for AI developers, system architects, and software engineers.

Mon, 01 Jan 0001 00:00:00 +0000

Support

How to file issues and get help

This project uses GitHub Issues to track bugs and feature requests. Please search the existing issues before filing new issues to avoid duplicates. For new issues, file your bug or feature request as a new Issue.

For help and questions about using this project, please:

Check the Azure AI Foundry Discord where experts and fellow developers gather
Use the Model Context Protocol Community resources for protocol-related questions

Microsoft Support Policy

Support for the Model Context Protocol (MCP) for Beginners project is limited to the resources listed above.

Mon, 01 Jan 0001 00:00:00 +0000

Follow these steps to start using these resources:

Fork the Repository: Click
Clone the Repository: git clone https://github.com/microsoft/mcp-for-beginners.git
Join The Azure AI Foundry Discord and connect with experts and fellow developers

🌐 Multi-Language Support

Supported via GitHub Action (Automated & Always Up-to-Date)

About

Mon, 01 Jan 0001 00:00:00 +0000

Intent Solutions

Independent AI consultancy. Production systems, not slide decks.

Founder: Jeremy Longshore Based: Gulf Shores, Alabama Contact: jeremy@intentsolutions.io · intentsolutions.io

What we ship

We build AI systems that go to production and stay there. The deliverables span four shapes — automation programs, agents and RAG systems, data and infrastructure foundations, and end-to-end product builds — but the through-line is the same: it has to run, every day, for real users, with telemetry and recovery in the box. Demos that never ship are someone else’s business.

Contact

Mon, 01 Jan 0001 00:00:00 +0000

The fastest way to reach me is email. Everything else is a slower lane.

Email

jeremy@intentsolutions.io — usually answered same day, almost always within 24 hours. If it’s been longer than that, it’s stuck in spam — DM on X or LinkedIn and I’ll dig it out.

What helps a first email

What you’re trying to do, in plain language. Not “explore an AI strategy” — “we have 6,000 PDFs of inspection reports and want to ask them questions in Slack.”
Where you are now. Codebase, vendor stack, who’s on the team, what’s already failed.
What “done” looks like. Even a rough sketch — production for real users, internal demo, board update — is enough to scope the conversation.
Timing. Soft deadline, hard deadline, or open-ended.

I don’t need a polished brief. A four-paragraph email beats a 30-page deck for getting to a useful first call.

Projects

Mon, 01 Jan 0001 00:00:00 +0000

What’s been shipping lately. Star counts and pushed dates pulled live from GitHub; pages on this site link out to the canonical repo or live URL.

Flagship — open source

claude-code-plugins-plus-skills · 2,100+★

The marketplace and ecosystem hub. 425 plugins, 2,810 skills, 200 agents for Claude Code — installable via the ccpi CLI package manager. Public marketplace at tonsofskills.com; source at github.com/jeremylongshore/claude-code-plugins-plus-skills.

This is the through-line for most of the other work — every plugin and skill listed below ends up in this hub. The ccpi package manager handles install, validation, and upgrade.

Research & Curriculum

Mon, 01 Jan 0001 00:00:00 +0000

AI Engineering Curriculum & Technical Papers

Welcome to our research collection featuring academic papers, technical studies, and in-depth analysis in AI development and systems architecture.

Featured Research

AI Development & Engineering

NEO: How to Build Vision-Language Models That Actually Understand Images - Comprehensive guide to NEO’s native vision-language architecture with practical implementation examples and code
How to Train AI Research Agents Without Spending $100K on Human Annotations - PokeeResearch-7B: Building production AI research agents using RLAIF (Reinforcement Learning from AI Feedback) instead of expensive human annotation
NLWeb: Building the AI Web with Natural Language Interfaces - Microsoft’s open-source framework for building conversational interfaces using MCP and Schema.org standards
The Coasean Singularity: How AI Agents Will Transform Digital Markets - NBER 2025 research examining how autonomous AI agents will reshape markets by reducing transaction costs to near-zero, enabling new economic structures (PDF)
Agentic Context Engineering: Evolving Contexts for Self-Improving LMs - Stanford/Princeton research on ACE framework treating AI contexts as evolving playbooks (+10.6% agent performance, +8.6% finance tasks)
Tiny Recursive Models: Less is More - Samsung research achieving 45% on ARC-AGI-1 with only 7M parameters through recursive reasoning
Model Context Protocol (MCP) for Beginners - Comprehensive Microsoft curriculum with hands-on labs in C#, Java, JavaScript, Rust, Python, and TypeScript
Hybrid AI Stack: Reduce AI Costs by 60-80% - Production-ready system that intelligently routes between local CPU models and cloud APIs to slash costs
Complete AI Engineering Curriculum - Comprehensive guide from zero to $200K+ AI engineering salary
Multi-Agent Architecture - Exploring distributed AI system design patterns

Systems Architecture & Patterns

Terraform for AI Infrastructure: Complete Guide - From zero to production: comprehensive Terraform learning resource for AI and cloud infrastructure
Distributed Systems Architecture Patterns - Comprehensive cheat sheet for scalable system design

Platform Engineering Case Studies

Building 254-Table BigQuery Schema in 72 Hours - Enterprise data platform architecture with 254 BigQuery tables
DiagnosticPro Evolution Analysis - Complete forensic analysis of 13,597 files in AI platform development
DiagnosticPro Platform Case Study - AI-powered vehicle diagnostics platform
DiagnosticPro Feature Rollouts - Preview of advanced AI diagnostic features

Developer Tools & Documentation

AI-Dev Transformation Part 1 - From chaos to organized AI-powered development
AI-Dev Transformation Part 2 - Building enterprise prompt libraries
AI-Dev Transformation Part 3 - One-paste magic template system
AI-Dev Transformation Part 4 - Dual AI workflows with Claude and Cursor
Building AI-Friendly Documentation - Professional documentation toolkit with Claude
Repository Transformation Guide - From chaos to professional prompt engineering toolkit

Security & Linux Systems

Comprehensive SSH, Debian & Grep Guide - Technical guide to SSH, Debian packages, and text processing
Waygate MCP v2.1.0 Production Release - Enterprise MCP server with TaskWarrior

Founder’s Journey & Development Insights

Methodology & Tools

Our research methodology emphasizes:

Subscribed!

Mon, 01 Jan 0001 00:00:00 +0000

You’re in. You’ll get an email when new posts go live. No spam, no fluff.

Back to posts →