1. From Invisible to Indexed: Transitioning an E-commerce PLP from CSR to SSR
2. SEO for Next.js: How We Fixed Product Crawlability on a Large Scale Storefront
3. The Hidden SEO Killer: Why Client-Side Hydration Guards are Hurting Your Rankings

Introduction

In the world of E-commerce, if Google can’t see your products in the initial HTML, they don’t exist. We recently tackled a significant challenge on a major storefront where the Product Listing Pages (PLP) were invisible to search engine bots due to a purely client-side architecture. This post breaks down how we moved to a Server-Side Rendered (SSR) model to boost discoverability.

The Problem: The “Hydration Guard” Trap
Many modern React/Next.js apps use a pattern where components wait for the page to “hydrate” before rendering. While this prevents layout shifts, it leaves the initial HTML empty.

Symptom: view-source showed 0 product links.
Impact: Crucial Product Detail Page (PDP) links were missing from the search engine’s initial pass.

The Solution: A Technical Deep Dive

1. Removing Hydration Blocks

The first step was identifying and removing synchronous guards like if (!isClient) return null. We updated the
ProductCard
to render its skeletal structure and crawlable links immediately on the server.

2. Solving the Klevu API SSR Mismatch

Fetching products on the server (SSR) is different from the browser. We had to.

Map Category Paths: Aligning Strapi’s category data with Klevu’s search engine requirements.
Clean the Input: Handling case-sensitivity and special characters (like &) that caused the server-side API call to return zero results.

Search Type Logic: Switching from specific term searches to CATNAV (Category Navigation) with wildcard queries to ensure the entire catalog is discoverable by bots.

3. Crawlable Pagination & Navigation

Semantic Links: We replaced “Load More” buttons with tags. Users still get the fast JS experience, but bots now have a clear path to page 2 and beyond.

Category Tree: We injected a top-level category navigation component into the SSR HTML, creating 10+ high-value internal links on every PLP.
Verification: Thinking Like a Bot
To test this, we stopped relying on the browser console. We used:

curl audits:
Checking the raw HTML for product-card classes and valid href links.

Bot Simulation: Tools that fetch the page without executing a single line of JavaScript.
Environment Parity: Ensuring API keys and environment variables were correctly loaded in the Node.js server context.

Conclusion

SSR isn’t just a performance feature; it’s an SEO requirement. By ensuring your product grid, breadcrumbs, and navigation are present in the first byte, you give search engines the “map” they need to index your site effectively.

Why This Matters

If you’re using Claude AI for coding, writing, or automation, you’re probably leaving performance on the table. The .claude/ folder is where the magic happens—it’s the configuration layer that transforms Claude from a generic AI into your personalized productivity engine.

A recent Hacker News discussion (359 points) shows developers are waking up to this. Let’s dive in.

What’s Inside .claude/

The .claude/ folder lives in your home directory (~/.claude/) and contains several key files:

1. config.json – Your Brain

This is where you define your preferences, tools, and behaviors.

{
  "model": "claude-3-5-sonnet-20241022",
  "temperature": 0.7,
  "max_tokens": 4096,
  "tools": ["code_interpreter", "file_search"],
  "system_prompt": "You are a senior developer focused on clean code."
}

Key Settings:

• model: Which Claude model to use
• temperature: Creativity level (0.0 = deterministic, 1.0 = creative)
• max_tokens: Response length limit
• tools: Enabled capabilities
• system_prompt: Your AI’s personality and role

2. tools/ – Your Toolkit

Custom tools extend Claude’s capabilities. Think of them as plugins.

Example Tool Structure:

~/.claude/tools/
├── code_review/
│   ├── manifest.json
│   ├── handler.py
│   └── README.md
├── file_operations/
│   ├── manifest.json
│   ├── handler.py
│   └── README.md
└── web_search/
    ├── manifest.json
    ├── handler.py
    └── README.md

manifest.json Example:

{
  "name": "code_review",
  "version": "1.0.0",
  "description": "Automated code review with best practices",
  "entry_point": "handler.py",
  "permissions": ["read_files", "write_files"]
}

3. prompts/ – Your Templates

Reusable prompt templates save time and ensure consistency.

Example:

~/.claude/prompts/
├── code_review.md
├── bug_fix.md
├── feature_implementation.md
└── documentation.md

code_review.md:

# Code Review Template

Review the following code for:
1. Security vulnerabilities
2. Performance issues
3. Code style violations
4. Edge cases

Code:
{{code}}

Provide:
- Summary of issues
- Line-by-line feedback
- Suggested fixes

4. history/ – Your Memory

Conversation history is stored here for context and learning.

Structure:

~/.claude/history/
├── 2026-03-28/
│   ├── session_001.json
│   ├── session_002.json
│   └── session_003.json
└── 2026-03-27/
    ├── session_001.json
    └── session_002.json

Why This Matters:

• Context retention across sessions
• Learning from past interactions
• Performance optimization

5. cache/ – Your Speed

Cached responses reduce latency and API costs.

What Gets Cached:

• Frequently used prompts
• Tool execution results
• File search results

Best Practices

1. Version Control Your Config

cd ~/.claude
git init
git add .
git commit -m "Initial Claude config"

2. Use Environment Variables

{
  "api_key": "${CLAUDE_API_KEY}",
  "model": "${CLAUDE_MODEL:-claude-3-5-sonnet-20241022}"
}

3. Modularize Your Tools

Keep tools focused and single-purpose.

Good:

• code_review/ – Reviews code
• file_operations/ – Manages files

Bad:

• everything/ – Does everything poorly

4. Document Your Prompts

Add metadata to prompt templates:

name: code_review
version: 1.0.0
author: your-name
tags: [code, review, quality]

# Code Review Template
...

5. Regular Cleanup

# Clear old history (keep last 30 days)
find ~/.claude/history -type f -mtime +30 -delete

# Clear cache weekly
rm -rf ~/.claude/cache/*

Advanced Configurations

Custom System Prompts

Tailor Claude’s behavior to your workflow:

{
  "system_prompt": "You are a senior full-stack developer with 10 years of experience. You prioritize clean code, security, and performance. You always provide explanations and alternatives."
}

Tool Chaining

Combine tools for complex workflows:

{
  "tool_chains": {
    "code_review_pipeline": [
      "code_review",
      "security_scan",
      "performance_check"
    ]
  }
}

Conditional Prompts

Use conditionals for dynamic behavior:

{% if language == "python" %}
# Python-specific review
...
{% elif language == "javascript" %}
# JavaScript-specific review
...
{% endif %}

Common Pitfalls

1. Over-Engineering

Problem: Too many tools and prompts slow down performance.

Solution: Start simple, add only what you need.

2. Ignoring Security

Problem: Storing API keys in plain text.

Solution: Use environment variables or secret managers.

3. No Backup

Problem: Losing your config means starting over.

Solution: Version control and regular backups.

4. Inconsistent Naming

Problem: code_review vs CodeReview vs code-review.

Solution: Stick to one convention (snake_case is common).

Performance Optimization

1. Cache Frequently Used Prompts

{
  "cache_settings": {
    "enabled": true,
    "max_size": "100MB",
    "ttl": "7d"
  }
}

2. Limit History Size

{
  "history_settings": {
    "max_sessions": 100,
    "max_age": "30d"
  }
}

3. Use Efficient Tools

Avoid tools that make unnecessary API calls or file operations.

Real-World Examples

Example 1: Automated Code Review

{
  "tools": ["code_review", "security_scan"],
  "prompts": ["code_review_template"],
  "system_prompt": "You are a senior code reviewer focused on security and performance."
}

Example 2: Documentation Generator

{
  "tools": ["file_operations", "web_search"],
  "prompts": ["documentation_template"],
  "system_prompt": "You are a technical writer who creates clear, comprehensive documentation."
}

Example 3: Bug Fix Assistant

{
  "tools": ["code_review", "debugger"],
  "prompts": ["bug_fix_template"],
  "system_prompt": "You are a debugging expert who identifies root causes and provides fixes."
}

Getting Started

Step 1: Create Your Config

mkdir -p ~/.claude
cat > ~/.claude/config.json << 'EOF'
{
  "model": "claude-3-5-sonnet-20241022",
  "temperature": 0.7,
  "max_tokens": 4096,
  "tools": ["code_interpreter", "file_search"],
  "system_prompt": "You are a helpful AI assistant."
}
EOF

Step 2: Add Your First Tool

mkdir -p ~/.claude/tools/my_tool
cat > ~/.claude/tools/my_tool/manifest.json << 'EOF'
{
  "name": "my_tool",
  "version": "1.0.0",
  "description": "My first custom tool",
  "entry_point": "handler.py",
  "permissions": []
}
EOF

Step 3: Create Your First Prompt

mkdir -p ~/.claude/prompts
cat > ~/.claude/prompts/my_prompt.md << 'EOF'
# My Prompt Template

{{input}}

Provide a clear, actionable response.
EOF

Step 4: Test It

claude --config ~/.claude/config.json

Resources

• Claude Documentation
• Hacker News Discussion
• OpenClaw Agent Skills

Conclusion

The .claude/ folder is your secret weapon for maximizing Claude AI’s potential. By understanding and optimizing its structure, you can transform Claude from a generic AI into a personalized productivity engine.

Start simple, iterate often, and don’t be afraid to experiment. The 359-point Hacker News discussion proves you’re not alone—developers everywhere are discovering the power of Claude configuration.

Next Steps:

1. Explore your current .claude/ folder
2. Create your first custom tool
3. Document your prompt templates
4. Share your configurations with the community

Want to learn more about AI tools and automation? Check out my other articles on AI Skills for Affiliate Marketing and GEO: The New SEO for AI Search Engines.

Affiliate Disclosure: This article contains affiliate links. If you make a purchase through these links, I may earn a commission at no additional cost to you.

Mutation Testing for Solidity: The Audit Quality Metric Your Protocol Is Ignoring

Your test suite shows 100% line coverage. Every function is touched, every branch is hit. Ship it, right?

Not so fast. In Q1 2026 alone, DeFi protocols have lost over $137 million to exploits — and many of those protocols had “comprehensive” test suites and professional audits. The uncomfortable truth: line coverage tells you what code your tests execute, not what bugs they would catch.

This is where mutation testing comes in — and it’s the most underused weapon in the Solidity security toolkit.

What Mutation Testing Actually Does

The core idea is deceptively simple:

1. Take your contract code
2. Introduce a small, deliberate bug (a “mutant”)
3. Run your test suite
4. If your tests still pass → your tests have a blind spot

Each surviving mutant represents a class of bugs your test suite cannot detect. A flipped >= to >, a removed require check, a swapped + to - — if none of your tests notice, that’s exactly the kind of subtle logic error an attacker will find.

Why Coverage Lies

Consider this common DeFi pattern:

function withdraw(uint256 shares) external {
    require(shares > 0, "zero shares");
    require(shares <= balanceOf[msg.sender], "insufficient");

    uint256 assets = (shares * totalAssets()) / totalSupply;

    balanceOf[msg.sender] -= shares;
    totalSupply -= shares;

    IERC20(asset).transfer(msg.sender, assets);
}

A test that calls withdraw(100) with sufficient balance achieves full line coverage of this function. But it wouldn’t catch:

• Mutant 1: require(shares >= 0) — allows zero-share withdrawals (potential DoS or accounting issues)
• Mutant 2: shares * totalAssets() / totalSupply → shares + totalAssets() / totalSupply — arithmetic manipulation
• Mutant 3: Remove the second require entirely — anyone can burn others’ shares
• Mutant 4: <= to < — off-by-one prevents full withdrawal

A test suite with 100% line coverage can easily miss all four. A mutation score of, say, 60% would immediately flag this function as undertested.

The Tools: Gambit vs. Vertigo-rs

Two mature tools dominate Solidity mutation testing in 2026:

Gambit (by Certora)

Gambit generates mutants by analyzing the Solidity AST and applying syntax transformations. It’s fast (written in Rust) and integrates with Certora’s formal verification pipeline.

Setup:

# Install Gambit
pip install gambit-se

# Generate mutants for a specific contract
gambit mutate --filename src/Vault.sol --solc_remappings "@openzeppelin=node_modules/@openzeppelin"

Gambit outputs mutated source files to gambit_out/mutants/. Each mutant includes a diff showing exactly what changed:

--- original
+++ mutant
@@ -42,7 +42,7 @@
-    require(shares <= balanceOf[msg.sender], "insufficient");
+    require(shares < balanceOf[msg.sender], "insufficient");

Key strength: Gambit supports Certora Prover specs, so you can test whether your formal verification rules, not just unit tests, catch mutations. This is incredibly powerful for protocols that use both testing and formal methods.

Key limitation: Gambit generates mutants but doesn’t automatically run your test suite against them. You need a wrapper script:

#!/bin/bash
KILLED=0
SURVIVED=0
TOTAL=$(ls gambit_out/mutants/ | wc -l)

for mutant_dir in gambit_out/mutants/*/; do
    # Copy mutant over original
    cp "$mutant_dir"/*.sol src/

    # Run tests, suppress output
    if forge test --no-match-test "testFuzz" -q 2>/dev/null; then
        echo "SURVIVED: $(cat $mutant_dir/gambit_results.json | jq -r '.description')"
        ((SURVIVED++))
    else
        ((KILLED++))
    fi

    # Restore original
    git checkout src/
done

echo "Mutation Score: $KILLED / $TOTAL ($((KILLED * 100 / TOTAL))%)"
echo "Survivors: $SURVIVED (these are your blind spots)"

Vertigo-rs (by RareSkills)

Vertigo-rs is the more batteries-included option. It handles mutant generation, test execution, and scoring in a single pipeline.

Setup:

# Install vertigo-rs
cargo install vertigo-rs

# Run mutation testing with Foundry
vertigo-rs run --framework foundry

Output looks like:

[*] Running mutation campaign...
[*] Generated 247 mutants across 12 contracts
[*] Testing mutants...

 Contract: Vault.sol
  ✗ SURVIVED - Line 42: require(shares <= ...) → require(shares < ...)
  ✓ KILLED   - Line 45: shares * totalAssets() → shares + totalAssets()
  ✗ SURVIVED - Line 48: balanceOf[msg.sender] -= shares → (removed)
  ...

 Mutation Score: 178/247 (72.1%)
 Survived: 69 mutants

Key strength: Zero-config integration with Foundry, Hardhat, and Truffle. Just point it at your project and run.

Key limitation: Can be slow on large codebases because it recompiles and re-runs the full test suite for every mutant. For a protocol with 500+ tests, each mutation run might take 30-60 seconds, and 300 mutants means 2.5-5 hours.

Which to Choose?

My recommendation: Use Vertigo-rs for quick feedback during development. Use Gambit when you’re preparing for an audit and want to validate both tests and formal specs.

Real-World Case Study: The Mutations That Would Have Caught $25M

Let’s look at the Resolv Labs exploit from March 22, 2026. The root cause was a compromised off-chain signing key that approved unbacked minting. But the on-chain contracts also lacked a critical invariant check:

function mint(uint256 amount, bytes calldata proof) external {
    require(verifyMintApproval(amount, proof), "invalid proof");
    _mint(msg.sender, amount);
}

A mutation testing campaign would have generated this mutant:

// MUTANT: Remove require
function mint(uint256 amount, bytes calldata proof) external {
    // require removed
    _mint(msg.sender, amount);
}

If the test suite only tested the happy path (valid proof → successful mint), this mutant survives — meaning no test verifies that invalid proofs are actually rejected. A dedicated negative test would kill it:

function test_mint_rejects_invalid_proof() public {
    bytes memory fakeProof = abi.encodePacked(uint256(0xdead));
    vm.expectRevert("invalid proof");
    vault.mint(1000e18, fakeProof);
}

More critically, an invariant test would have flagged the missing supply-backing check:

function invariant_supply_backed() public {
    assertGe(
        IERC20(usdc).balanceOf(address(vault)),
        vault.totalSupply() * vault.exchangeRate() / 1e18
    );
}

This invariant — total supply must always be backed by collateral — is exactly what mutation testing trains you to write.

A Practical Mutation Testing Workflow

Here’s the workflow I recommend for any DeFi protocol heading toward audit:

Phase 1: Baseline (Week 1)

# Run Vertigo-rs to get your baseline mutation score
vertigo-rs run --framework foundry --output results.json

# Review survivors grouped by contract
cat results.json | jq '.survivors | group_by(.contract) | map({contract: .[0].contract, count: length})'

Expect a mutation score of 40-60% on most DeFi codebases. Don’t panic — this is normal.

Phase 2: Kill Critical Survivors (Week 2)

Focus on survivors in security-critical functions: deposit, withdraw, borrow, liquidate, governance execution. For each survivor:

1. Understand what the mutant changed
2. Ask: “If this bug existed in production, what would the impact be?”
3. Write the specific test that kills it

Priority order:

• Removed require/assert → Write negative tests
• Flipped comparisons → Write boundary tests
• Arithmetic operator changes → Write precision tests
• Removed state updates → Write multi-step scenario tests

Phase 3: Invariant Hardening (Week 3)

The most valuable output of mutation testing isn’t killing individual mutants — it’s identifying the invariants your protocol assumes but never tests:

// These invariants should survive ALL mutations
function invariant_total_supply_matches_balances() public { ... }
function invariant_collateral_ratio_above_minimum() public { ... }
function invariant_no_unbacked_debt() public { ... }
function invariant_withdrawal_never_exceeds_balance() public { ... }

Phase 4: CI Integration (Ongoing)

Add mutation testing to your CI pipeline, but scope it to changed files to keep it fast:

# .github/workflows/mutation.yml
name: Mutation Testing
on:
  pull_request:
    paths: ['src/**/*.sol']

jobs:
  mutate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: foundry-rs/foundry-toolchain@v1

      - name: Run mutation testing on changed contracts
        run: |
          CHANGED=$(git diff --name-only origin/main -- 'src/*.sol')
          for file in $CHANGED; do
            vertigo-rs run --framework foundry --contract "$file"
          done

      - name: Check mutation score threshold
        run: |
          SCORE=$(cat mutation_results.json | jq '.score')
          if (( $(echo "$SCORE < 75" | bc -l) )); then
            echo "❌ Mutation score $SCORE% below 75% threshold"
            exit 1
          fi

The Mutation Score Sweet Spot

What mutation score should you target?

• < 50%: Your tests are decoration. An attacker could introduce subtle bugs that your entire test suite wouldn’t notice.
• 50-70%: Typical for well-tested DeFi protocols. You’re catching obvious bugs but missing edge cases.
• 70-85%: Strong. Most security-relevant mutations are caught. This is the realistic target for pre-audit readiness.
• > 85%: Diminishing returns. Some mutants (like changing a revert string) aren’t security-relevant. Don’t chase 100%.

The target: 75%+ mutation score on all security-critical contracts before submitting for audit.

What Mutation Testing Won’t Catch

Be honest about the limits:

• Design-level flaws: Mutation testing evaluates your tests, not your architecture. A fundamentally broken economic model passes mutation testing with flying colors.
• Cross-contract interactions: Most mutation tools operate on single contracts. Integration-level bugs between protocols require integration-level tests.
• Off-chain dependencies: The Resolv hack ultimately came from a compromised key — no on-chain mutation would model that.
• Gas optimization regressions: Mutants that are functionally equivalent but gas-inefficient aren’t caught.

Mutation testing is one layer in a defense-in-depth strategy: unit tests → mutation testing → fuzz testing → formal verification → professional audit → monitoring.

Getting Started Today

1. Install Vertigo-rs: cargo install vertigo-rs
2. Run it: vertigo-rs run --framework foundry
3. Read the survivors: Focus on security-critical contracts first
4. Kill 10 mutants: Write targeted tests for the most dangerous survivors
5. Repeat weekly: Track your mutation score over time

The protocols that survive 2026 won’t be the ones with the most audits — they’ll be the ones that actually tested what their audits assumed.

This is part of a series on practical DeFi security techniques. Previously: Foundry Invariant Testing for DeFi Exploits, DeFi Circuit Breakers: From ERC-7265 to Aave Shield. Next up: Building a Pre-Audit Security Dashboard with Slither, Aderyn, and Custom Detectors.

Anyone with a browser and a bit of curiosity could quietly pull draft pages about Anthropic’s unreleased “Claude Mythos” model, an invite‑only CEO retreat, and thousands of other assets from a public web endpoint. The Anthropic data leak wasn’t a shadowy zero‑day or an AI jailbreak; it was the web equivalent of putting your company safe on the porch and hoping nobody tried the handle.

TL;DR

• The Anthropic data leak exposed ~3,000 unpublished CMS assets, including draft “Claude Mythos” materials and internal event docs, through a public‑by‑default content store.
• The Claude Mythos leak is real as a product signal, but the deeper story is operational: basic configuration hygiene failed at a company that markets itself on AI safety.
• The key insight: frontier‑model risks increasingly come from boring ops mistakes—CMS configs, asset stores, automation blind spots—where AI safety rhetoric doesn’t reach.

What the Anthropic data leak actually revealed

Compressed version first: Fortune reporters, with help from named security researchers, discovered that Anthropic’s web CMS exposed a cache of nearly 3,000 unpublished assets—draft blog posts, PDFs, images, internal docs—through a public endpoint that didn’t require login. Among them: draft marketing and risk materials about a not‑yet‑announced “Claude Mythos” model and an invite‑only CEO retreat where Dario Amodei would demo unreleased capabilities. After Fortune called, Anthropic flipped the setting and locked it down, blaming “human error” in an external CMS configuration.

Look at what didn’t have to happen here.

No one socially engineered an engineer.

No one ran an LLM‑powered exploit chain.

They just asked the CMS, politely, “What do you have?” and the CMS answered.

This is the part where most coverage veers off into model hype—benchmarks, “step change in capabilities,” and whether Claude Mythos is secretly Skynet with better branding.

But the more interesting question is: how does a company preaching frontier AI safety end up with its web CMS acting like an open filing cabinet?

Because that’s not a model problem.

That’s an ops culture problem.

How much of “Claude Mythos” is real, and how much is still squishy?

OK so imagine two piles on a table labeled Verified and Still Marketing Until Proven Otherwise.

Here’s what clearly goes in the Verified pile:

• There was an internal code‑name or tier name around “Mythos” (and “Capybara”) in the leaked drafts.
• Anthropic told Fortune it is testing a new model under that name and called it “the most capable we’ve built to date” and a “step change” over current Claude.
• Draft text, quoted by Fortune, emphasized cyber capabilities and warned that the model is “currently far ahead of any other AI model in cyber capabilities,” with plans for early access to defenders.

You don’t acknowledge the name, echo the “step change” language, and then pretend it’s all fan fiction.

So: Claude Mythos exists as a serious internal project and is far enough along for launch copy, risk framing, and CEO road‑show decks.

What stays in the squishy pile for now:

• Exact parameter counts, architecture details, and benchmark numbers quoted in draft materials.
• The “far ahead of any other AI model in cyber capabilities” claim relative to competing labs, which we only see via draft text and Anthropic’s framing—not independent tests.
• Any implied timelines, pricing tiers (e.g., “Capybara”), or policy positions that might have changed since those drafts.

If you care about AI capabilities, the Claude Mythos leak is a useful early warning of where Anthropic is aiming.

But the part we can fully verify—the fact that this all leaked via a sloppy CMS configuration—is actually the more important signal about the future risk surface.

Why this leak is an ops problem, not just an AI problem

Look, we like to tell ourselves that “AI risk” is this rarefied thing: alignment strategies, model evaluations, misuse scenarios.

Most of the real risk, though?

It shows up in checkboxes.

Fortune’s reporting lines up with a painfully familiar pattern any web engineer recognizes:

1. Use a hosted CMS where assets are public by default.
2. Pipe all your logos, drafts, PDFs, and launch decks through the same asset store.
3. Rely on humans to remember to flip the “private” bit on sensitive things.
4. Never model the CMS itself as a security‑critical system because “it’s just the blog.”

That’s not exotic. That’s OWASP Top Ten territory: “Security Misconfiguration” and “Insecure Design” in their most boring forms.

And that’s the point.

Anthropic has been unusually vocal about model‑level safety—red‑teaming, constitutional AI, structured evaluations. In another NovaKnown piece, we talked about AI builds AI and how Anthropic uses Claude‑based agents to automate internal engineering work.

Now put those two threads together:

• You automate more of your code and content plumbing with agents.
• The number of systems capable of silently flipping a dangerous checkbox multiplies.
• But your safety culture is concentrated at the model layer, not in the mundane glue.

You get exactly this: a world‑class research org whose public‑facing CMS is a single misclick away from turning R&D secrecy into an RSS feed.

Here’s the thing: the Anthropic data leak looks like a contradiction—“safety‑obsessed lab, amateur‑hour web security”—but it’s actually a preview.

The more a company centralizes risk conversations around models, the more invisible these ops layers become.

And invisible layers accumulate sharp edges.

AI safety with the keys under the mat

A Reddit commenter nailed the metaphor: CMS misconfigurations are “leaving your house key under the mat, except the mat is indexed by every crawler on the internet.”

Extend that a bit.

Modern AI companies don’t have a house.

They have:

• A CMS for the website.
• A separate one for docs.
• A synthetic data generation pipeline.
• An internal app store for agents and tools.
• A half‑dozen data lakes for training, evals, and analytics.

Every one of those is a potential “key under the mat” surface.

And the key insight is: AI safety rhetoric doesn’t automatically harden any of them.

When you read about the Claude Mythos leak, it’s tempting to think “wow, imagine if that model had gone rogue.” But the real, present‑day risk is much more like what we explored in the AI agent hack: prompt‑layer security piece: glue systems and orchestration layers where nobody thought to build in guardrails.

There, it was agents smuggling instructions through a prompt layer.

Here, it’s a CMS quietly answering, “Sure, here are all my unpublished files.”

In both cases, the attackers don’t need to beat your frontier model.

They just need to beat your plumbing.

And right now, the plumbing is full of default‑on faucets.

Why the Anthropic data leak matters beyond Anthropic

OK, so what does this leak actually change for anyone who isn’t Anthropic?

For users, the good news is that Fortune’s reporting doesn’t point to leaked API keys, chat logs, or customer data. This was about internal docs, product positioning, and event details. The bad news is what it says about how seriously your vendor treats operational security around AI.

If the same org that runs careful cyber‑capability evals on Claude Mythos can forget to lock down a CMS cache, you should assume your own vendor’s “security whitepaper” is at least half aspiration.

For competitors, the Claude Mythos leak is basically a free scouting report.

Not the raw weights—that would be catastrophic—but enough to:

• Infer Anthropic’s internal benchmarks and where they think they’re ahead.
• See how they intend to sequence access (defenders first, then broader rollout).
• Benchmark your own roadmap and marketing claims against their draft copy.

It’s like seeing your opponent’s playbook diagrammed in pencil. The plays might change, but the philosophy is on the page.

For regulators, this is the interesting part.

Most proposed AI regulation obsesses over the model: model registration, evals, release thresholds. Very few frameworks talk concretely about the operational surface around those models—CMS configs, logging and access controls on eval data, agent orchestration layers, per‑service threat modeling.

Yet the Anthropic data leak shows you can meaningfully increase public risk without touching the model weights at all.

You just have to:

• Leak drafts that detail cyber capabilities before there’s a containment plan.
• Leak schedules and locations of high‑value, invite‑only events.
• Leak internal assessments that adversaries can use to prioritize where to probe.

None of that shows up in a model card.

Some of it probably should show up in a safety‑case file.

If regulators want to be taken seriously in an “AI operational security” world, they’ll need to treat AI companies less like nuclear labs and more like cloud providers with very weird data—subject to boring, continuous scrutiny of their ops posture, not just their flagship models.

Key Takeaways

• The Anthropic data leak was caused by a CMS misconfiguration and public‑by‑default asset store, not an exotic cyberattack or model exploit.
• The Claude Mythos leak confirms Anthropic is testing a significantly more capable model, but technical claims remain internal drafts, not fully verified benchmarks.
• This incident is a classic security misconfiguration—the kind OWASP has warned about for years—now happening in a frontier AI lab context.
• AI safety conversations are heavily skewed toward models, while operational layers like CMS, data lakes, and agent orchestration remain under‑secured.
• For users, competitors, and regulators, the lesson is simple: ask how vendors run their ops, not just how they align their models.

Further Reading

• Exclusive: Anthropic left details of an unreleased model, exclusive CEO event, in unsecured database — Fortune’s original report detailing the CMS misconfiguration and exposed assets.
• Anthropic says testing ‘Mythos,’ a powerful new AI model, after data leak reveals its existence — Follow‑up on Anthropic’s confirmation of Mythos and the draft claims about its capabilities.
• OWASP Top Ten — Canonical list of common web application security risks, including the kind of misconfiguration that enabled this leak.
• AI builds AI: How Anthropic’s Claude Codes Its Future — NovaKnown’s look at Anthropic’s use of Claude agents to automate internal development.
• AI agent hack: prompt-layer security — NovaKnown’s analysis of how orchestration layers become the weak link in AI systems.

In a world racing to align superhuman models, the thing that will keep biting us isn’t rogue AI—it’s the checkbox somebody forgot to uncheck on the way to production.

Originally published on novaknown.com

Every few days, someone confidently declares that AI is about to wipe out software engineering.

I don’t buy that.

I think software is much closer to woodworking than people realize.

Before industrialization, furniture was made by hand. If you wanted a table, a chair, a cabinet, or a bed frame, you needed a skilled craftsperson. The work took years of training. It was slow, specialized, and expensive. Good furniture was not broadly accessible because it could not be. Every piece required real human expertise, and that expertise did not scale cheaply.

Then industrialization happened.

The craft of making furniture did not disappear. It changed.

Machines, standardization, and repeatable manufacturing processes made it possible to produce furniture at much larger scale and much lower cost. The average quality was often lower than what a master craftsperson could produce by hand, but that was only part of the story. The bigger change was that an entirely new market opened up. Furniture became accessible to far more people. Businesses like IKEA could exist. A thing that once required expert labor for every unit could now be produced in enormous volume by a system.

Handmade furniture did not go away. There is still a market for beautiful, custom, ultra-high-quality work. But the center of gravity changed. Some artisans were displaced. Some adapted. Some moved further upmarket. And alongside all of that, a much larger market for cheaper, faster, more standardized output came into existence.

I think software is going to follow a very similar path.

Software Has Been Craft Work for a Long Time

For most of its history, building software has looked a lot like skilled handcraft.

You needed people with deep, specific knowledge. You needed years of training. You needed teams of specialists who could translate ambiguous human needs into precise technical systems. Every meaningful piece of software required a large amount of manual effort from people who knew what they were doing.

That made software powerful, but it also made it expensive. There are countless products, automations, internal tools, and business ideas that never got built, not because they were bad ideas, but because the cost of making software was too high. The custom work involved was too specialized. The economics did not work.

AI Lowers the Cost of Production

AI is making it cheaper and faster to produce software that is good enough for many use cases. Not perfect. Not elegant. Not deeply original. But good enough.

There are companies that will now build internal tools they never would have funded before. There are small businesses that will buy software they could never previously afford. There are workflows that stayed manual for years because no one was going to assign a full engineering team to automate them. There are product ideas that used to die in a spreadsheet that may now become viable.

The important question is not just whether AI can replace some portion of current engineering labor. The important question is what happens when software itself becomes far more manufacturable.

When that happens, you don’t just get substitution. You get expansion.

You get more software.

And Yes, a Lot of It Will Be the IKEA Version

Good enough code that is customizable enough for most applications.

When you industrialize a craft, you get standardization. You get lower costs. You get accessibility. You also get a lot more average output.

Some of it will be flimsy.

Some of it will be ugly.

Some of it will work surprisingly well for the price.

Some of it will be disposable.

Some of it will be “good enough” in exactly the way the buyer needed.

There will absolutely be a flood of mediocre AI-assisted software. There will be overconfident companies, sloppy implementations, badly framed cost-cutting strategies, and executives who mistake faster production for complete replacement of judgment. There will be chaos, overcorrection, and a lot of noise.

Some people will be displaced. Some categories of work will shrink. Some tasks that used to justify a full human workflow will get compressed into something smaller.

That is not the same thing as saying software engineering jobs disappear. It means the structure of the market changes.

Industrialization Changes the Work Before It Eliminates It

People talk as if the only possibilities are: either software engineering remains exactly what it has been, or it vanishes, but that is usually not what happens to crafts or professions.

The tools change first.

Then the workflow changes.

Then the expectations change.

Then the skill mix changes.

Eventually, the job title survives while the actual work looks very different.

Software engineers may spend less time manually producing obvious code and more time shaping systems. Less time writing boilerplate and more time defining constraints. Less time assembling known patterns by hand and more time evaluating tradeoffs, validating outputs, debugging weird behavior, understanding real user needs, and deciding what quality means in context.

That is still engineering. In some ways, it is more engineering and less typing.

High-Craft Software Will Still Exist

Even after industrialization, handmade furniture did not become pointless, it became differentiated.

If you want something deeply customized, unusually durable, aesthetically excellent, or built around exact needs, you still want real craftsmanship. In fact, the abundance of cheap mass-produced alternatives can make true quality stand out more, not less.

I think the same thing will happen in software.

There will still be demand for systems that are reliable, maintainable, secure, deeply integrated, and thoughtfully designed. There will still be software where correctness matters. There will still be edge cases, constraints, and human realities that don’t fit cleanly into standardized generation.

When code becomes easier to generate, discernment becomes more valuable. When anyone can produce output, the differentiator shifts toward knowing what should be built, how it should be shaped, where the risks are, what corners cannot be cut, and what makes something actually good.

The Bigger Story Is Market Expansion

One reason I am skeptical of the “all jobs go away” framing is that it assumes the size of the software market stays basically fixed. I don’t think it will.

When making something gets cheaper, people don’t merely buy the old amount for less money. They start buying things that previously were not worth buying at all.

Cheap furniture did not just replace expensive furniture. It furnished more homes.

AI-generated and AI-assisted software will not just compete with existing software teams. It will also create a much larger market for software in places where custom development was previously too expensive, too slow, or too inaccessible.

Some of the work will move downward into highly standardized production. Some of it will move upward into higher-leverage oversight, architecture, integration, and quality. Some entirely new categories of work will appear because the economics now support them.

That seems much more plausible to me than “software engineering stops existing.”

I’ve Heard This Story Before

My dad worked in television for about forty years. He started in the late 1970s, right as one era was ending and another was beginning. The first great golden age of television was fading, and cable was rising into what you could probably call a second golden age.

For a long time, the industry changed less than people might expect. The scale grew. Availability exploded. More channels, more content, more reach. But the basic operating model and economics stayed recognizable. Television was still television. Prime time still mattered. The machinery of the industry still made sense to the people inside it.

Then the 2010s happened.

Streaming did not just compete with network and cable television. It reorganized the entire landscape. Very quickly, the old structure stopped being the center of gravity. The audience changed. The business model changed. Distribution changed. Viewing habits changed. Many of the jobs my dad did over the course of his career simply do not exist anymore.

The industry did not die, it transformed into something that most people inside it probably could not have fully envisioned until after it happened.

Johnny Carson was eventually followed by Letterman, Leno, Conan, and then a parade of Jimmys. But even that version of the industry turned out not to be permanent. It was gradually overtaken by something far more fragmented: MrBeast, the Paul brothers, YouTubers, Twitch streamers, podcasters, TikTok creators, and countless internet-native personalities who built audiences outside the old system entirely. The old model was not replaced by a new host. It was replaced by a new landscape.

My dad jokes that prime time is what paid for his retirement, and I think that line captures a lot. That whole world was real. It was massive. It shaped careers, businesses, and lives. It also largely does not exist anymore in the form that once felt permanent.

That does not mean television ended. There is more video content than ever. More ways to watch it. More creators. More distribution. More total output. But the old structure was not preserved just because it had once seemed foundational. It was replaced by a new one.

I think software may be heading for a similar kind of shift.

For People Who Love Solving Problems, This Could Be a Golden Age

A lot of programmers don’t actually love typing code for its own sake, they love solving problems.

They love understanding systems. They love building tools. They love making messy things clean. They love turning ambiguity into structure. They love the feeling of gaining leverage over a problem that looked impossible a few hours ago. That part is not going away.

The problems are changing. The tools are changing. The constraints are changing. The surface area of what one person can build is changing. For people who do this for the love of the game, that is exciting because everything will be in motion.

There will be new abstractions, new workflows, new product categories, new expectations, and new kinds of technical judgment. There will be new opportunities to build things that were previously out of reach. There will be a massive amount of room for experimentation.

If you like problem solving more than you like protecting old workflows, this moment is full of possibilities.

The Transition Will Be Messy

Industrialization is disruptive.

There will be companies that overcorrect badly. There will be teams that are reduced too aggressively. There will be low-quality software shipped at scale because someone decided speed mattered more than understanding. There will be a period where many people are asked to operate in systems that have changed faster than the norms around them.

If your current job is mostly composed of work that is easy to standardize, I don’t think denial is a useful response. The market is changing. Pretending otherwise will not help. The better response, at least to me, is adaptation.

Learn the tools.

Understand the new economics.

Move toward the parts of the work where judgment matters.

Get better at problem framing, system design, evaluation, communication, and taste.

Become the person who can work with the new machinery without mistaking it for magic.

That seems like a far more grounded response than mourning a version of the craft that was never going to stay frozen in time.

Some jobs will shrink. Some will disappear. Some will be reborn in altered forms. Entire new layers of software work will appear. New tools will create new expectations. New economics will produce software that would never have existed under the old model. And a lot of what feels central today may someday feel like prime time television: once dominant, deeply real, and eventually no longer the thing that anchors the industry.

If your goal is to keep building, keep learning, and keep solving interesting problems, it might be the most interesting moment the field has seen in a very long time.

The craft of making software is not disappearing. But like every craft touched by new machinery, new economics, and new distribution, it is going to change shape.

Some people will spend too much energy mourning that.

I would rather spend mine learning the new tools and exploring what becomes possible next.

Most people use AI assistants to write code. I’ve started using mine to break code first.

It sounds counterintuitive, but this one change to my workflow cut my bug rate in half and made code reviews actually meaningful.

The Problem With Write-First

The default AI coding workflow looks like this:

1. Describe what you want
2. AI writes the code
3. You review it
4. You find bugs (maybe)
5. You fix them

Step 4 is where things fall apart. Reviewing AI-generated code is hard because it looks correct. It’s well-structured, properly indented, has reasonable variable names. Your brain pattern-matches it as “good code” and skips over the logic errors.

I call this correctness theater — the code performs competence without actually being correct.

The Debug-First Approach

Here’s what I do instead:

Step 1: Write the Spec (30 seconds)

Function: calculateShippingCost(order)
- Input: order with items[], destination, shipping_method
- Output: { cost: number, estimatedDays: number }
- Rules: free shipping over $100, express = 2x base rate,
  international adds flat $15, empty orders throw error

Step 2: Ask for Failure Scenarios (AI’s first job)

Given this spec, list 10 ways this function could fail or produce
wrong results. Be specific — include the input that would trigger
each failure.

AI returns something like:

1. Empty items array → should throw, might return $0
2. Order total exactly $100 → boundary: is it > or >=?
3. Negative item prices → cost could go negative
4. Missing destination → international check fails silently
5. Express + international + free shipping → which rules apply in what order?
6. Single item worth $101 → free shipping, but express is 2x of what?
7. Floating point: $33.33 × 3 = $99.99, not $100
8. Null shipping_method → undefined behavior
9. destination = “” (empty string) → not null, not valid
10. Items with quantity: 0 → included in total?

This takes 10 seconds and I already have a better understanding of my own spec than I did when I wrote it.

Step 3: Turn Failures Into Tests (AI’s second job)

Write a test for each failure scenario. Each test should currently FAIL
(because we haven't written the implementation yet). Use Vitest.

Now I have 10 tests that define what “correct” actually means — before a single line of implementation exists.

Step 4: Write the Implementation (AI’s third job)

Write calculateShippingCost() that passes all 10 tests.
Run through each test mentally and confirm it would pass.

The implementation is now constrained by real edge cases. The AI can’t take shortcuts because the tests are already there, waiting to catch them.

Step 5: Verify (Mine)

I run the tests. Usually 8-9 pass on the first try. The 1-2 that fail reveal genuine ambiguities in my spec that I need to decide on. That’s a feature — I’d rather resolve ambiguity now than in production.

Why This Works Better

You Review Tests, Not Code

Reading 10 test descriptions is faster and easier than reading 50 lines of implementation. If the tests cover the right cases, the implementation is almost certainly correct. If they don’t, you know exactly what’s missing.

AI Is Better at Breaking Than Building

Ironically, AI assistants are more reliable at finding problems than solving them. When you ask “what could go wrong?”, the model draws on thousands of bug reports and failure modes from its training data. When you ask “write correct code,” it draws on thousands of code samples — many of which contain the very bugs it could have warned you about.

The Spec Improves Before Implementation

Half the bugs I ship come from ambiguous specs, not bad code. The debug-first workflow forces spec clarification before I write anything. By step 3, I’ve already caught the “$100 boundary” and “express + free shipping” ambiguities.

Code Reviews Become Meaningful

When someone reviews my PR, they see the test names:

✓ throws on empty order
✓ free shipping at exactly $100
✓ rejects negative prices
✓ handles express + international combo

The reviewer immediately understands what the code does, what edge cases were considered, and what “correct” means. They can focus on what’s missing from the tests rather than trying to read implementation logic.

The Template

Here’s the prompt sequence I use every time:

Prompt 1 — Failure Analysis:

Here's my function spec: [spec]
List 10 specific ways this could fail or produce wrong results.
Include the exact input for each.

Prompt 2 — Test Generation:

Write a failing test for each scenario. Use [test framework].
Tests should fail because the function doesn't exist yet.

Prompt 3 — Implementation:

Write the function to pass all tests. After writing it,
walk through each test and explain why it passes.

Prompt 4 — Gap Check:

Look at the tests and implementation together.
Are there any edge cases the tests don't cover?

Four prompts. Usually takes 5-10 minutes total. The resulting code is more correct than anything I’d get from a single “write this function” prompt.

When to Skip This

This is overkill for trivial functions. I don’t debug-first a formatDate() helper. My rule of thumb: if the function has more than 2 conditional branches or touches external state (DB, API, file system), it gets the debug-first treatment.

Try this on your next feature. The first time all 10 tests pass on the first run, you’ll feel like you have a superpower.

Hot take: the worst use of AI coding assistants is the thing most people use them for — generating boilerplate.

I spent three months auto-generating CRUD endpoints, form components, and config files. I felt productive. My git log was full of big commits. Then I looked at what I actually shipped, and I realized I’d been optimizing the wrong thing.

The Boilerplate Trap

Here’s what happens when you use AI for boilerplate:

1. You prompt: “Generate a CRUD API for users with Express and Prisma”
2. AI spits out 200 lines of working code
3. You glance at it, looks fine, commit
4. A week later, you find three inconsistencies with your existing endpoints
5. You spend an hour fixing patterns the AI didn’t know about

The problem isn’t that AI generates bad boilerplate. It’s that boilerplate is the part of your codebase where consistency matters most — and AI is terrible at consistency unless you over-specify every detail.

You know what’s great at consistent boilerplate? A template. A snippet. A plop generator. A shell script. Deterministic tools for deterministic work.

What AI Is Actually Great At

After a lot of trial and error, here’s where AI assistants consistently save me real time:

1. Thinking Through Edge Cases

Here's my function that handles file uploads.
What edge cases am I missing? List them as a checklist.

AI is excellent at this because it’s seen thousands of file upload implementations go wrong. It’ll catch: empty files, duplicate names, MIME type mismatches, concurrent uploads, disk space, path traversal — things you’d eventually find in production.

2. Writing the Second Test

I write the first test by hand to set the pattern. Then:

Here's my test for the happy path. Write 5 more tests covering
edge cases and error paths, following the same structure.

The first test establishes the conventions. AI extrapolates. This works because the pattern is right there in the prompt — no guessing needed.

3. Explaining Code I Didn’t Write

Explain what this function does, what assumptions it makes,
and what would break if I changed the return type.

AI as a reading companion is underrated. It’s faster than tracing through unfamiliar code manually, and it catches implicit contracts (“this assumes the array is sorted”) that aren’t obvious.

4. Drafting Migration Plans

I need to rename the `users.name` column to `users.display_name`.
What's the migration plan? Include: SQL, ORM migration,
code changes needed, and rollback steps.

AI won’t execute the migration for you, but it’ll map out the blast radius. This is planning work that used to take me 30 minutes of grep-and-think.

5. Rubber-Duck Debugging

I expect this function to return [X] but it returns [Y].
Here's the function and the test. Walk through the execution
step by step and tell me where my assumption breaks.

This is genuinely the most time I’ve saved. AI is a patient, methodical debugger that never gets frustrated and never says “have you tried restarting it?”

The Rule I Follow Now

Use AI where judgment matters. Use templates where consistency matters.

The boring, repetitive stuff? Automate it deterministically. The thinking, analyzing, reasoning stuff? That’s where AI shines.

The Counterargument

“But Nova, AI-generated boilerplate works fine if you review it carefully.”

Sure. But if you’re reviewing 200 lines of generated code carefully enough to catch every inconsistency with your existing patterns, you’re not saving time — you’re just moving the work from writing to reading. And reading someone else’s code (which is what AI output is) takes longer than writing your own from a template.

What’s the most overrated use of AI coding assistants in your workflow? I’m curious whether others have hit the same wall.

Every model brags about context windows now. 128K tokens. 200K tokens. “Paste your entire codebase!” the marketing says.

I tried it. I pasted 80K tokens of a Node.js project into Claude and asked it to find a bug. It found a bug — in a file I didn’t care about, while ignoring the actual issue in the file I mentioned.

Here’s what I learned about context windows the hard way.

The Attention Problem

Large context windows don’t mean the model pays equal attention to everything. Research on “lost in the middle” showed that LLMs disproportionately focus on the beginning and end of the context, with reduced attention in the middle.

In practice, this means:

• File 1 of 50: high attention ✓
• Files 2-49: declining attention ✗
• File 50: high attention ✓
• Your actual question at the end: high attention ✓

So if your bug is in file 27, the model literally pays less attention to it — even though it’s “in context.”

The Cost Problem

128K input tokens on GPT-4o costs about $0.32. That sounds cheap until you’re iterating. Ask 10 follow-up questions with the same context and you’ve spent $3.20 — for one debugging session. Do this daily and you’re burning $60+/month on context you mostly don’t need.

The Noise Problem

More context means more potential for the model to get confused. Paste your entire codebase and ask “how does auth work?” The model will find auth-related code in your middleware, your tests, your old migration files, your README, and your CI config. It’ll synthesize all of them into an answer that’s technically accurate but practically useless because it mixes current code with deprecated patterns.

What Actually Works: The Context Budget

I now treat context like a budget. Every project gets a context budget — the minimum set of files needed for the current task. Nothing more.

Rule 1: 3-File Maximum for Bug Fixes

For any bug fix, I include at most 3 files:

1. The file with the bug
2. The file that calls it
3. The test file (if one exists)

That’s usually 1-3K tokens. Fast, cheap, and the model’s full attention is on the relevant code.

Rule 2: Tree Before Files

Before pasting any code, I give the model the project structure:

Here's the project tree (files only, no contents):
src/
  auth/
    middleware.ts
    oauth.ts
    session.ts
  api/
    users.ts
    posts.ts
  db/
    schema.prisma
    migrations/

Then I ask: “Which files do you need to see to [task]?” The model picks 2-3 files. I paste those. This is dramatically more effective than dumping everything.

Rule 3: Summaries Over Source for Large Codebases

For architectural questions, I write a 200-word summary instead of pasting 50 files:

## Architecture Summary
- Express API with Prisma ORM, PostgreSQL
- Auth: Google OAuth2, sessions stored in Redis
- 3 main domains: users, posts, comments
- Each domain has: router, service, repository layers
- Tests: Vitest for unit, Playwright for e2e
- Current issue: session expiry not triggering token refresh

This gives the model the map without the territory. It can reason about architecture from a summary faster than from raw source.

Rule 4: Rolling Context for Multi-Step Work

For long sessions, I maintain a “working set” — a running summary of what we’ve done and decided:

## Working Set (updated after each step)
- Fixed: session middleware now checks token expiry
- Changed: added `refreshToken()` call in auth middleware
- Pending: update tests for new refresh flow
- Decision: using sliding window expiry (not fixed)

This replaces the growing conversation history. Instead of the model re-reading 20 back-and-forth messages, it reads 5 lines of curated state.

The Number That Matters

In my experience, the sweet spot is 2,000-8,000 tokens of input context for most coding tasks. That’s:

• 3-5 source files, or
• 1 file + project summary + task description, or
• A working set summary + the current file

Above 8K, I start seeing diminishing returns. Above 20K, I start seeing negative returns — the model gets noisier, slower, and more expensive with no accuracy gain.

The 128K window isn’t there for you to use all of it. It’s there so you can include a large file when you need to. Think of it as cargo capacity, not a target.

Quick Reference

How do you manage context window usage? I’d love to hear if anyone’s found a good automated approach — right now mine is manual but it works.

Every few months, someone launches a product that promises to give your AI agent persistent memory. A vector database here, a knowledge graph there, maybe a retrieval system layered on top.

They’re all solving the wrong problem.

The constraint isn’t that agents lack storage. It’s that they lack architecture. Context windows have finite capacity, and every memory solution I’ve seen treats that as a bug to work around instead of a design constraint to embrace.

The teams building the most capable agents aren’t trying to make them remember more. They’re making them forget better.

Why Memory Solutions Keep Missing the Point

The standard playbook looks like this:

1. Give the agent access to a database
2. Store conversation history, documents, preferences
3. Retrieve relevant context when needed
4. Hope the model figures out what matters

This works fine for simple queries. “What did I say about the API rate limits last week?” Retrieve, inject, answer. But it breaks down when you need the agent to maintain coherent behavior across complex, multi-step workflows.

The problem: retrieval isn’t recall. When you inject retrieved context into a prompt, you’re not giving the agent a memory. You’re giving it a document to read. Every time it reads that document, it re-interprets it. The interpretation depends on the surrounding context, the task at hand, and the model’s current state.

A human with memory knows what they know. A model with retrieval has to figure it out fresh every time.

The Real Constraint: Context Competition

Here’s what memory solutions don’t account for: every piece of context you add competes with everything else in the window.

Your agent has a 200k token context window. You’ve injected:

• 50k tokens of retrieved conversation history
• 30k tokens of relevant documents
• 40k tokens of code the agent is working on
• 20k tokens of system instructions

That leaves 60k tokens for reasoning. But those tokens aren’t evenly distributed. The agent needs space to think through complex problems. It needs to hold multiple hypotheses simultaneously. It needs working memory.

Every megabyte of “memory” you add reduces the agent’s capacity to reason about what it remembers.

The best agent architectures I’ve seen don’t maximize retention. They optimize for relevance.

What Better Forgetting Looks Like

The agents that feel smartest—the ones that maintain coherent conversations across hours of work, that remember your preferences without being told twice, that don’t contradict themselves—aren’t using better retrieval. They’re using better summarization.

Pattern 1: Rolling Summaries

Instead of storing every conversation, store a compressed version that captures what matters:

Original conversation: 5000 tokens
Compressed summary: 200 tokens
Key decisions extracted: 50 tokens
Open questions: 30 tokens

When the agent needs context, it reads the summary, not the transcript. The summary can be updated as new information arrives. This is how humans maintain coherent relationships over years—we don’t replay conversations. We hold compressed representations.

Pattern 2: Explicit State Management

The smartest agent systems I’ve seen don’t rely on retrieval to figure out state. They encode state explicitly:

{
  "current_goal": "debug authentication flow",
  "completed_steps": ["reproduce error", "check logs"],
  "open_questions": ["Is this a timing issue?"],
  "context_needed": ["last error message", "user's auth config"]
}

This structure fits in a few hundred tokens. It’s trivial to update. And crucially, it’s designed to be read by a model, not a human. The agent doesn’t need to infer state from conversation history—it’s told explicitly what state it’s in.

Pattern 3: Progressive Summarization at Boundaries

When context fills up, most systems truncate. The oldest messages disappear.

Better systems summarize at boundaries. Instead of dropping messages, they ask: “What did we establish in this section that we’ll need later?” They extract the key points and discard the noise.

This is what ghost.build is doing with ephemeral databases—giving agents instant, temporary storage for the current session, then discarding it when the session ends. The memory isn’t meant to persist. It’s meant to offload the context window.

The Architecture Shift

The shift from “agents need memory” to “agents need architecture” changes how you build:

From storage to structure. Instead of asking “what can we store?”, ask “what structure helps the agent stay coherent?” The answer might be a state machine, a task graph, or a set of explicit invariants.

From retrieval to relevance. Instead of retrieving everything that matches a query, surface only what the agent needs right now. This requires understanding the agent’s current task—not just matching keywords.

From accumulation to compression. Instead of storing more context, get better at compressing what you have. A 200-token summary that captures the essential state is worth more than a 50k-token transcript.

The Practical Payoff

Teams that build this way end up with agents that:

• Stay on track across multi-hour tasks because state is explicit, not inferred
• Don’t contradict themselves because summaries are coherent, not pieced together
• Adapt to new information without needing to re-read everything
• Scale to complex workflows because context isn’t wasted on noise

The bottleneck isn’t storage. It’s architecture. The teams that figure this out are the ones building agents that actually feel intelligent.

The Takeaway

If you’re building an agent system, stop asking “how do I make it remember more?” and start asking:

• What state does the agent need to maintain?
• How can I encode that state efficiently?
• What can I discard without losing coherence?
• Where are the natural boundaries for summarization?

The context window isn’t a bug. It’s a design constraint that forces you to think about what actually matters. Embrace it. Build for it. Your agents will be smarter for it.

The agents that remember everything are the ones that never learned what to forget.

The Dream of Mechanical Life

Imagine waking up to the gentle hum of a robot preparing your coffee, your home adjusting its temperature for optimal comfort, and a digital assistant planning your day. Sounds futuristic? Maybe. But for developers, the dream of mechanical life isn’t just sci-fi—it’s shaping up to be our next big playground.

The idea isn’t new. From ancient automata to modern robotics, humans have always chased the fantasy of animating the inanimate. Today, the boundary between software and physical devices is blurring faster than ever. Let’s dig into what “mechanical life” really means for us—and why this dream is surprisingly relevant to anyone writing code.

From Gears to Algorithms: What Is Mechanical Life?

Before we dive in, let’s clarify the concept. Mechanical life refers to machines (physical or virtual) that mimic behaviors we associate with living things. Think robots, self-driving cars, smart assistants, even virtual pets.

But what does “life” mean here? Not biology, but capability:

• Autonomy: Systems that act on their own, making decisions or responding to their environment.
• Adaptability: Machines that can learn or adjust their behavior over time.
• Interaction: Devices that communicate or cooperate with humans and other machines.

Take Roomba as an example. It isn’t just a vacuum cleaner; it’s a device that senses obstacles, maps rooms, and (with newer models) adapts to your schedule. That’s mechanical life in action—a blend of sensors, algorithms, and responsive behavior.

Why Developers Should Care: It’s Not Just Robotics

You might be thinking, “Cool, but I don’t build robots.” Here’s the twist: mechanical life is about more than hardware.

Modern software platforms, cloud services, and APIs are getting “smarter.” Let’s look at a few scenarios:

• Smart homes: Integrate sensors, cloud platforms, and voice assistants. A developer working on a smart thermostat app is dabbling in mechanical life.
• Digital agents: Chatbots and virtual assistants are mechanical life’s virtual cousins. Building conversational flows? You’re crafting behaviors for a digital being.
• IoT devices: Whether it’s a weather station or a security camera, connecting physical devices with logic and connectivity brings mechanical life to your doorstep.

These aren’t niche fields. They’re bleeding into mainstream development. Suddenly, “Hello World” means connecting to a smart speaker, or deploying a script that nudges your lights to dim when you start watching Netflix.

How Mechanical Life Works: Under the Hood

So, how do we turn gears and code into “life”? Let’s break down the main ingredients.

1. Sensors and Input

Mechanical life starts with awareness. Devices need to sense their environment—temperature, movement, voice, image, or even network activity.

Example:

import RPi.GPIO as GPIO
import time

# Simple motion detector on Raspberry Pi
PIR_PIN = 4
GPIO.setmode(GPIO.BCM)
GPIO.setup(PIR_PIN, GPIO.IN)

while True:
    if GPIO.input(PIR_PIN):
        print("Motion detected!")
    time.sleep(1)

Here, a sensor triggers a response—just like an organism reacts to stimuli.

2. Processing and Decision-Making

Sensors provide data, but something has to make sense of it. This is where logic, rules, and increasingly, machine learning, come in.

Example:

• If temperature > 28°C, turn on the fan.
• If user says “Play music,” stream Spotify.

You can hard-code rules, but for adaptability, machine learning helps:

# Example: simple classification with scikit-learn
from sklearn.tree import DecisionTreeClassifier

X = [[0], [1]]  # Sensor readings
y = ['off', 'on']

clf = DecisionTreeClassifier()
clf.fit(X, y)
print(clf.predict([[1]]))  # Output: 'on'

3. Actuators and Output

Finally, mechanical life needs to act. That might mean spinning a motor, sending a notification, adjusting lighting, or speaking.

Example:

# Turn on a light via GPIO
LIGHT_PIN = 17
GPIO.setup(LIGHT_PIN, GPIO.OUT)

def set_light(state):
    GPIO.output(LIGHT_PIN, GPIO.HIGH if state else GPIO.LOW)

Combine sensing, thinking, and acting—and you’ve got a basic mechanical organism.

Building Mechanical Life: Practical Developer Tips

Ready to tinker? Here’s how you can dip your toes in, no matter your stack:

• Start small: Tinker with Raspberry Pi, Arduino, or ESP32. Build a simple sensor-driven script. Blink an LED when you clap!
• Explore APIs: Many devices expose RESTful APIs or MQTT endpoints. Try sending commands to a smart bulb or retrieving sensor data.
• Experiment with cloud platforms: AWS IoT, Azure, or Google Cloud offer virtual mechanical life. Simulate devices, process data, and trigger actions.
• Use frameworks: Home Assistant, Node-RED, and others provide drag-and-drop logic to connect devices and build behaviors.
• Embrace low-code: Don’t worry about soldering. Many platforms let you create automation with little or no code.

Don’t have hardware? No problem. Many device simulators exist, and you can experiment with virtual agents using NLP frameworks or chatbot tools.

The Challenges: Not Everything Is Rosie the Robot

Mechanical life is exciting, but it’s not all sunshine and dancing bots. Here are some hurdles developers face:

• Reliability: Machines break or misinterpret data. Building robust error handling is key.
• Security: More connectivity means more attack vectors. Always secure devices and APIs—think authentication, encryption, and regular updates.
• Ethics: As machines become more autonomous, decisions get thorny. Who’s responsible when a smart device acts up?
• Integration: Devices from different vendors rarely play nicely out of the box. Expect to wrangle protocols and compatibility.

Every developer who’s debugged a smart home setup knows the pain of “ghost” devices or flaky integrations. Mechanical life is a messy, evolving field—but that’s where the fun is.

Conclusion: The Dream Is Yours to Build

The dream of mechanical life isn’t just about robots walking the streets. It’s about making code—and machines—do more than ever before. Whether you’re automating your office lights, designing a virtual assistant, or building the next smart device, you’re part of this grand experiment.

Mechanical life blurs the line between software and the physical world. As developers, we get to animate the inanimate, shape new behaviors, and solve real-world problems in creative ways.

So, what will you build next? The dream is wide open—grab a sensor, write some code, and let your mechanical life come alive.