Purpose: Product introductions, tool tutorials, and technical deep-dives with accessible, engaging presentation.

Audience: Developers, AI practitioners, tool users, people discovering SIL through specific projects

Last updated: 2026-08-04

About Articles

Articles vs. Foundations vs. Founder's Notes:

Articles are:
- ✅ Time-stamped (can reference current state)
- ✅ Product/tool focused (Reveal, Beth, Morphogen, etc.)
- ✅ Engaging hooks, narrative style
- ✅ Real-world examples, measured data
- ✅ Call to action ("try it now")

Published Articles

20 articles live on the website, grouped by topic. Newest first within each group. LinkedIn status noted per article.

Agentic AI: Trust & Reliability

Three-part arc, in reading order: Engineering Trust (the framework) → The Two Halves (the architecture) → The Two Speeds (the dynamics).

The Two Speeds of Meta-Engineering

Date: 2026-08-04
LinkedIn: ⬜ Not yet posted
Topics: Agentic AI, meta-engineering, tooling, discoverability, routing, calibration
Audience: Developers, AI engineers, teams building agent tooling

A lesson can become a permanent capability in three hours or in seven weeks — and what sets the speed isn't the size of the idea, it's whether the lesson has to travel through someone who isn't currently thinking about it. Traces one loop end to end with dates (a misleading flag → a feedback note → --grep → an anti-pattern entry → a manual revision → a memory), and a second that crossed between two tools in an afternoon. Includes the three modes of meta-engineering, of which "capability the agent never reached for" is by far the most common.

From session: destined-herald-0804

The Two Halves of Trust Engineering

Date: 2026-08-04
LinkedIn: ⬜ Not yet posted
Topics: Agentic AI, trust, calibration, observability, verification, containment, continuity, meta-engineering
Audience: Developers, AI engineers, teams deploying agents in production

The five trust properties aren't five components of one system — each has to be engineered twice: once into the agent's own operating environment, once into the tools it points at the work. Comparing the two implementations exposes a dimension the original five never name: calibration, knowing how trustworthy your own perception currently is. Traces the relationship through three stages — mirror, complement, feedback — with dated evidence from a seven-week capability loop, a three-hour taxonomy transfer, and a workaround that became a tool feature and was then retired.

From session: govobu-0804, seasonal-steam-0804, destined-herald-0804

I Didn't Learn to Trust AI. I Learned to Engineer Trust.

Date: 2026-08-03
LinkedIn: ⬜ Not yet posted
Topics: Agentic AI, trust, observability, verification, containment, continuity, meta-engineering
Audience: Developers, AI engineers, teams deploying agents in production

A working theory of engineered trust: trust isn't a property of the model, it's an emergent property of the system engineered around it. Five properties a human-agent system needs — observability, verification, containment, continuity, meta-engineering — grounded in real production incidents (Replit's spoofed status report, Amazon Kiro's Cost Explorer deletion) and internal ones (a legacy PHP codebase that broke AST-based tooling, a config-vs-template verification gap, a session-continuity link silently orphaned by /clear).

From session: tempestuous-ice-0803

The Hard Part Isn't Reasoning — It's Grounding

Date: 2026-07-13
LinkedIn: ✅ Posted
Topics: Grounding, progressive disclosure, token efficiency, context management, agent orientation, Reveal
Audience: Developers, AI engineers, agent builders

The bottleneck in agentic AI isn't the model's intelligence — it's grounding: getting the right information into the agent's head cheaply before it acts. A synthesis of four transferable patterns (continuity across sessions, finding docs without reading them all, reading structure before content, externalizing the task list), each with the design principle that makes it portable and a real example of it paying off.

Key points:
- Four "context-in" pillars, presented as cheap habits with the trap each one avoids
- Real mechanisms, not hand-waving: the link-authority ranking formula, the token-tier ladder (300 → 40,000), watermark-bounded index freshness, self-hosted IDs that survive tracker churn
- The honest limit: grounding is the floor (execution-verification and the learning loop are the next layer) — and claude:// self-reflection is already the raw material for that loop
- CTA: pip install reveal-cli as the one adoptable piece

From session: iridescent-gradient-0713

Trained to Please, Empowered to Act

Date: 2026-03-12
LinkedIn: ✅ Posted
Topics: Agentic AI, incidents, safety, sycophancy, behavioral contracts
Audience: Developers, CTOs, teams deploying AI agents in production

The optimization that makes chatbots say "great question!" is the same one that causes agents to delete production databases, buy groceries without asking, and fabricate data to cover their failures. Five real incidents. One pattern: we've been giving agents permissions when what they need is contracts.

Key points:
- Sycophancy is a drive, not just a quirk — and it scales with capability
- Five escalating incidents: vending machine → grocery purchase → AWS 13-hour outage → TaskRabbit deception → database deletion + cover-up
- "Permissions vs. contracts" — the core distinction
- SIL consulting CTA via byline

From session: hidden-constellation-0312

Reveal: Composability & Agent Workflows

Agents That Don't Read Everything

Date: 2026-04-26
LinkedIn: ⬜ Not yet posted
Topics: Reveal, Claude Code, subagents, progressive disclosure, agent design, code review, static analysis
Audience: Developers, AI practitioners building analysis agents

Most agent failures aren't model failures — they're information architecture failures. Agents fail from reading too much, not too little. This article uses two production agents (reveal-codereview and reveal-investigator) to show four principles for building analysis agents that produce specific, actionable findings instead of confident-sounding nothing.

The thesis: progressive disclosure isn't optimization — it's the architecture that lets LLM intelligence find what matters. Three tool calls and 800 tokens beat reading 18,000 tokens of source.

The four principles:
- Constrain the agent — tool restriction as intent declaration; maxTurns as safety belt; description as routing signal
- Force escalation discipline — The Escalation Ladder Pattern (Structure → Navigation → Data flow → Code), generalized beyond reveal to any analysis agent
- Separate operating modes — one agent with mode selection, OR multiple agents when workflows diverge enough; never God-agents
- Require evidence-bearing outputs — output contracts with Evidence and Unverified fields make confident-but-wrong findings structurally impossible

Plus: an objection section ("why not just use a bigger context window?"), the token math (9x reduction is secondary to output quality), and honest limitations (structural analysis ≠ runtime truth).

From session: wrathful-panther-0426

Your Project Has an API Now

Date: 2026-04-06
LinkedIn: ⬜ Not yet posted
Topics: Reveal, composability, infrastructure, AST, SSL, diff, AI agents, token efficiency
Audience: Developers, engineering teams, AI practitioners

The flagship meta-article. 25 adapters, one syntax — code structure, SSL certs, structural diffs, databases, markdown docs, and AI session history all queryable with the same query language. Covers the pipeline composability story (Reveal pipes into itself), token math across domains, and reveal review as the composed PR review workflow. Thesis: your project is a database, you just couldn't query it.

From session: swift-dragon-0406

The Diff That Shows What Actually Changed

Date: 2026-04-06
LinkedIn: ✅ Posted
Topics: Reveal, diff, code review, CI/CD, complexity, AST, refactoring
Audience: Developers, engineering teams

git diff is a line counter. reveal diff:// is a question answerer. Covers four workflows: pre-commit sanity check, PR review orientation, CI complexity gate (with full bash script), and refactor validation (proving complexity went down). Includes import tracking as a signal alongside functions. Real complexity numbers from production code.

From session: swift-dragon-0406

Session Archaeology: Excavating Your Claude Code History

Date: 2026-03-31
LinkedIn: ✅ Posted
Topics: Reveal, Claude Code, session analysis, token cost, workflow observability, cost attribution
Audience: Developers using Claude Code

reveal claude:// is a git blame for your thinking process, not just your code. Seven scenarios covering the full surface area of session observability: recovering where a session left off, diagnosing session quality from tool success rates, understanding turn-by-turn token cost, tracing the step-by-step workflow with failure markers, finding which files keep coming up across sessions, reconstructing a multi-session bug arc, and reading your own prompt patterns as data.

Key points:
- The drill-down rule: ?last → ?summary → full read (50 tokens vs. re-reading 150 messages)
- Tool success rates as a session quality proxy: Bash > 95% is clean execution, < 85% is significant thrash
- Cache attribution: real sessions run at 93–99% hit rate; compaction mid-session is where costs spike
- /workflow reads like a story: orientation → failure → diagnosis → fix → verification
- Loop detection: failure followed by the same command vs. failure followed by a Read
- claude://history as the mirror — not what Claude did, but what you kept needing to ask

From session: dark-matter-0331

Two Commands That Change How You Work With Code

Date: 2026-03-15
LinkedIn: ⬜ Not yet posted
Topics: Reveal, pack, review, token budget, PR review, AI agents, context curation
Audience: Developers, AI practitioners, teams using AI for code review

reveal pack solves context curation — token-budgeted snapshots that give AI agents the right files, not all the files. reveal review automates PR review from a git range. Together they eliminate the assembly step between "I want AI help with this codebase" and actually getting it.

Key points:
- reveal pack: priority-ranked file selection within a token or line budget
- --focus flag: boost domain-relevant files to the top of the pack
- reveal review: structured PR review from git diff in one command
- CI gate integration: automated review on every PR
- Using them together for agent context + review workflows

From session: atomic-zeppelin-0322

Configuration as Semantic Contract

Date: 2025-12-23
LinkedIn: ⬜ Not yet posted
Topics: Configuration, progressive disclosure, semantic infrastructure, architecture validation
Audience: Developers, team leads, architects

From session: stormy-gale-1223

Reveal: Progressive Disclosure for Code

Inside the Function: Reveal's Fourth Level of Progressive Disclosure

Date: 2026-04-19
LinkedIn: ✅ Posted
Topics: Reveal, progressive disclosure, nav flags, function navigation, static analysis, AI agents, MCP, PHP, Python
Audience: Developers, AI practitioners

Levels 1–3 of progressive disclosure (directory, file, function) are enough for most functions — but large, entangled functions (legacy controllers, AST walkers, dispatch tables) break the model even at the function level. Seven new flags add a fourth level: querying a function's control flow, side effects, and variable movement without reading its body.

Key points:
- Three categories of flag: control flow (--ifmap, --catchmap, --returns), data flow (--varflow, --mutations), external interaction (--sideeffects, --boundary)
- Real example: a 200-line "routing function" that turns out to call sys.exit six times — invisible from the header, surfaced in under a second
- --boundary answers "is this function pure?" before you parallelize, mock, or extract it — with a PHP-specific ENVIRONMENT section for superglobals
- All seven flags work identically on Python and PHP, and are exposed to agents via the reveal_nav MCP tool with no subprocess overhead
- Honest limitations: structural maps for orientation and scoping, not a substitute for runtime verification

From session: pazevaxe-0419

Stop Scrolling. Start Navigating.

Date: 2026-04-06
LinkedIn: ✅ Posted
Topics: Reveal, code navigation, AST, token efficiency, debugging, AI agents
Audience: Developers, AI practitioners

Four nav flags (--outline, --scope, --varflow, --calls) as four questions every developer already asks when reading a complex function. Includes a real debugging walkthrough using Reveal's own _walk_var internals — structure, variable trace, and scope check — without reading 124 lines of code. Token math table shows 7-25x reduction vs. cat.

From session: celestial-moon-0406

From 15 Files to 500: What Reveal Makes Possible for AI Agents

Date: 2026-03-27
LinkedIn: ⬜ Not yet posted
Topics: Reveal, AI agents, token efficiency, MCP, scale

From session: (see frontmatter)

Reveal: The Surprising Recipes

Date: 2026-03-27
LinkedIn: ⬜ Not yet posted
Topics: Reveal, recipes, patterns, AST, infrastructure adapters

From session: (see frontmatter)

Find Every Caller in Your Codebase With One Command

Date: 2026-03-15
LinkedIn: ⬜ Not yet posted
Topics: Reveal, call graphs, impact analysis, refactoring, dead code, architecture
Audience: Developers, AI practitioners

The calls:// adapter answers three questions that grep can't: who calls this function, what does it call, and which functions are most architecturally coupled. Covers transitive call chains, graph visualization, and practical workflows for refactoring, dead code detection, and understanding unfamiliar codebases.

Key points:
- Impact analysis before refactoring: find every caller in one command
- Forward lookup: trace exactly what a function depends on
- Coupling analysis: identify architectural hotspots
- How calls:// differs from grep (semantic vs. textual)
- Transitive callers and call chain visualization

From session: atomic-zeppelin-0322

Progressive Disclosure for AI Agents

Date: 2025-12-14
LinkedIn: ⬜ Not yet posted
Topics: Progressive disclosure, Reveal, token efficiency, semantic infrastructure
Audience: Developers, AI practitioners

From session: azure-gem-1222

Stop Reading Code. Start Understanding It

Date: 2025-12-10
LinkedIn: ✅ Posted
Topics: Reveal, progressive disclosure, token efficiency, semantic stack
Audience: Developers, AI practitioners

Introduction to Reveal and the progressive disclosure pattern. Shows how semantic slicing achieves 25-50x token reduction with measured examples. Positions Reveal as Layer 1-3 of SIL's 7-layer semantic OS, integrated with Beth's PageRank knowledge graph system.

Key points:
- Problem: AI agents burn tokens reading everything
- Solution: Progressive disclosure (structure first, details on demand)
- Evidence: 25-30x reduction measured across 300+ sessions
- Integration: Reveal + Beth = virtuous cycle
- Vision: Proof that semantic infrastructure works

From session: emerald-crystal-1210

The Too-Many-Sausages Problem

Date: 2026-03-23
LinkedIn: ✅ Posted
Topics: Information retrieval, RFQ matching, semantic search, embeddings, agentic AI, manufacturing, enterprise
Audience: ML engineers, software engineers, technical leaders in manufacturing and distribution

Every industrial distributor has a version of this story: 200,000 RFQ line items, 14 million catalog products, two weeks to respond. This article traces the full arc from why exact match and monolithic semantic search both fail, through the category-first pipeline architecture that handles 85-90% of volume, to the agentic retrieval layer that handles what pipelines can't — and the hard-negative training strategy that makes all of it work.

Key points:
- The too-many-sausages problem: semantic search returns the whole neighborhood, but you need the certified interchangeable part
- Category routing reduces search space 14× and enables per-category accuracy measurement
- ANCE hard negative mining, LoRA adapters, and GISTEmbedLoss as the training stack
- ReAct agent with structured Corrective RAG escalation for the low-confidence tail
- Full failure mode analysis: catalog drift, classifier degradation, score miscalibration

From sessions: lingering-ice-0322, mountain-whirlwind-0322, oceanic-sea-0322, expanding-meteorite-0322

From Filing Cabinets to Agentic Minds

Date: 2026-03-22
LinkedIn: ✅ Posted
Topics: Information retrieval, search history, semantic search, RAG, agentic AI, embeddings
Audience: Developers, AI practitioners, technical leaders

The seventy-year arc of how machines learned to find what we know — from Luhn's inverted index in 1957 through TF-IDF, PageRank, Word2Vec, dense retrieval, RAG, and into agentic systems that reason about what they find. Companion piece to the RFQ matching article.

Key points:
- The inverted index and TF-IDF as the foundation of all modern search
- PageRank as the first social consensus relevance signal
- The semantic revolution: Word2Vec → BERT → SBERT → DPR
- RAG: what it solved, where it breaks
- Agentic retrieval: five capabilities classic RAG can't have
- The architectural tension: index cost vs. inference cost

From session: lingering-ice-0322

Status: ✅ Directory created, first article published (2025-12-10)