The Amnesia Tax: Why Stateless Agents Are Eating Your Margins

Every time your AI agent forgets a conversation, someone pays for it. Usually you.

The viral post making the rounds—your agent can think. it can’t remember.—gets the diagnosis right. But it misses the economics.

Memory isn’t a feature. It’s infrastructure. And right now, most teams are running production workloads on infrastructure that forgets everything every session.

Here’s what that actually costs.

The Hidden Tax Rate

When an agent can’t remember:

• Every task starts from zero. No accumulated context about your codebase, your preferences, your quirks.
• Every correction is paid twice. You re-explain the same constraints, the same gotchas, the same “don’t do X” rules.
• Every debugging session is archaeological. You reconstruct what the agent would have known if it had memory.

I watched a team spend 45 minutes debugging why their agent kept making the same mistake. The agent had no memory of the previous 12 corrections. Each session, they were essentially paying the onboarding cost again.

That’s not inefficiency. That’s a subscription to repeating yourself.

Why This Is Different From “Bad Prompts”

The usual response to agent quality issues is “write better prompts.”

But prompts can’t solve amnesia.

A perfectly crafted prompt that teaches your agent about your architecture, your coding standards, your deployment rituals—that prompt is useless the moment the session ends. The agent treats every conversation like it’s meeting you for the first time.

You’re not fighting prompt quality. You’re fighting statelessness by design.

The Three Memory Gaps

Most agent conversations focus on one gap: conversation history. But there are actually three:

1. Session Memory (what happened in this chat)

This is partially solved by context windows. But context windows aren’t memory—they’re buffers. They overflow. They’re expensive. And they reset.

2. Workflow Memory (what patterns does this user prefer)

Does your agent know you prefer inline comments over docstrings? That you like verbose logging? That you hate nested ternaries?

If not, it’s guessing. Every. Single. Time.

3. System Memory (what’s true about this codebase)

Your agent should know the architectural decisions, the intentional tech debt, the “don’t touch” modules. Without this, it’s a tourist in your codebase.

The Architecture Shift

The fix isn’t bigger context windows. It’s persistent memory architecture.

This means:

• MCP (Model Context Protocol) servers that persist context across sessions
• Memory files that store workflow preferences and architectural decisions
• Project-level configuration (like CLAUDE.md) that teaches the agent the rules once

The teams getting real productivity gains aren’t using smarter models. They’re building systems that remember.

The Business Case

Here’s the calculation most teams miss:

If your agent saves you 2 hours per day but forgets everything overnight, you’re paying a re-onboarding tax every morning. That might be 15 minutes. It might be an hour.

If it’s 30 minutes daily, that’s 10% of your agent productivity vanishing into amnesia.

The teams I’ve seen solve memory aren’t seeing incremental gains. They’re seeing step functions. Because the agent stops wasting cycles relearning what it already knew.

What To Do Monday Morning

1. Audit your amnesia. How much context do you re-enter every session? Time it for a week.

2. Check your infrastructure. Are you using MCP servers? Persistent memory files? Or just hoping the context window holds?

3. Write the rules once. If you find yourself typing the same instructions repeatedly, that’s a memory file waiting to happen.

The agent memory conversation has been stuck on can they? The real question is what does it cost if they can’t?

Your margins know the answer.

In the last decade, we were told that the “Cloud” was the final destination for all data. But as we move through 2026, a new shift is happening. For us as engineering students, the real magic isn’t happening in a distant data center—it’s happening right in our pockets, on our wrists, and in our local sensors.
1.⁠ ⁠The Latency Problem
Imagine an autonomous drone or a smart medical monitor. If these devices have to send data to a server thousands of kilometers away just to make a decision, the delay (latency) could be catastrophic. Edge Computing solves this by processing data right where it’s generated.
2.⁠ ⁠AI Gets Local (Agentic AI)
We are seeing the rise of Agentic AI—models that don’t just answer questions but take actions. In 2026, the goal is “On-Device AI.” By running smaller, optimized versions of LLMs locally, we achieve:

• Privacy: Your data never leaves your device.
• Speed: Instantaneous response times.
• Reliability: The system works even without an internet connection.
  3.⁠ ⁠Sustainability & “Green Code”
  Processing everything in massive data centers consumes a staggering amount of energy. As future engineers, we have a responsibility toward Sustainable Tech. Edge computing reduces the “data traffic” on global networks, leading to a smaller carbon footprint for our applications.
  The Bottom Line
  The “Cloud” isn’t going away, but it is becoming the brain for long-term memory, while the “Edge” becomes the nervous system for real-time action. For those of us building the next generation of software, mastering Edge-Native development isn’t just an advantage—it’s a necessity.

If you’ve ever noticed Claude Code ignoring rules you carefully wrote in
your CLAUDE.md, you’re not imagining it.

I spent hours adding instructions to my config file, only to watch Claude
keep doing the exact things I told it not to. After digging into how
Claude Code actually processes CLAUDE.md, I found four specific reasons
this happens.

1. Your file is too long

Claude Code starts selectively ignoring content after around 80 lines.

This isn’t a bug — it’s a fundamental limitation of how LLMs process
instructions. Frontier models can reliably follow approximately 150
instructions. Once you exceed that, the model starts making judgment
calls about what to pay attention to.

Most CLAUDE.md files I’ve seen are 100-200+ lines. Mine was 140 lines.
I had no idea this was a problem.

Fix: Keep your CLAUDE.md under 80 lines. Every line should answer
the question: “Would removing this cause Claude to make mistakes?”
If not, cut it.

2. You have contradicting instructions

This one is subtle. If your file says “use tabs for indentation” in one
section and “use 2-space indentation” in another, Claude can’t follow
both — so it often ignores both.

These contradictions are hard to spot manually, especially in longer files
that have been edited over time by multiple people.

Fix: Audit your file for conflicting rules. Pay special attention to
code style, testing requirements, and workflow instructions.

3. You’re wasting tokens on personality lines

Lines like these are extremely common:

You are a senior software engineer.
Be concise, helpful, and professional.
Think step by step carefully.
Always write clean, high-quality code.

These do almost nothing. Claude Code already has strong system-level
instructions baked in. Personality lines waste tokens without changing
behavior — and worse, they push your actual important instructions
further down the file.

Fix: Delete every line that doesn’t give Claude specific, actionable
information about your project.

4. You’re using @file references wrong

Writing @docs/architecture.md in your CLAUDE.md embeds that entire
file into every single session. This bloats your context window
immediately and leaves less room for actual work.

Fix: Instead of embedding files, tell Claude when to read them:

For architecture questions, see docs/architecture.md
For API integration issues, see docs/stripe-guide.md

How bad is your CLAUDE.md?

I scored mine after learning all this: 34/100. Grade F.

I had 4 errors and 11 warnings in a file I thought was fine.

After fixing everything: 91/100. Grade A. Claude’s behavior
noticeably changed — it stopped ignoring my testing requirements and
started following my workflow instructions consistently.

I built a CLI tool to automate this analysis:

pip install agentlint-dev
agentlint score CLAUDE.md

Output:

Score: 34/100  Grade: F — Critical Issues

  Length & Density   0/25
  Specificity       19/25
  Structure         10/25
  Completeness       5/25

It catches contradictions, token waste, duplicate rules, missing
commands, @file abuse, and more. Works with CLAUDE.md, AGENTS.md,
and Cursor rules.

→ agentlint.carrd.co

The minimal CLAUDE.md template

If you want to start fresh, here’s the structure that scores highest:

# Project
[2-3 sentences: what this project does]

# Stack  
[language, framework, key libraries]

# Commands
- Test: npm test
- Build: npm run build
- Lint: npm run lint

# Rules
- [specific rule 1]
- [specific rule 2]

# Never
- [thing Claude should never do]

# Verify
After changes, run tests and confirm they pass before marking done.

Under 80 lines. No personality instructions. Specific commands.
Clear rules. This is what a 90+ score looks like.

What does your CLAUDE.md score? Run agentlint and let me know in
the comments.

!(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/mbmjeg2peb497j1m593e.png)

An architecture-aware engineering principles framework for Claude Code, built for real work on existing codebases: bug fixes, feature work, refactoring, code review, migration, and more. Instead of treating every request the same way, Sextant routes work by task type, applies rules that match the size of the change, and makes principle conflicts explicit instead of leaving them to guesswork.

1. Why Sextant Exists

If you have used Claude Code on anything more serious than a toy project, you have probably seen the same patterns.

Sometimes it starts editing too early. It reads the error trace, opens one nearby function, and jumps into a fix before it has actually located the root cause.

Sometimes it ignores the shape of the existing system. You ask for a feature, and instead of extending the pattern that is already there, it invents a new one.

And sometimes it applies the wrong amount of process. A tiny local change gets treated like an architecture exercise, while a cross-module change gets handled as if it were just a one-file patch.

Sextant is built around a simple idea: first establish a safe baseline, then figure out what kind of task this is, and then apply the rules that make sense for that kind of change. The goal is not to add ceremony. The goal is to help Claude Code make better decisions before it starts modifying code.

2. Task-Type Routing Instead of One Generic Workflow

Sextant is not one monolithic prompt. It is a set of specialized sub-skills, and Claude Code automatically matches the user’s request to the most relevant one.

That matters because a bug fix should not behave like a migration, and a code review should not behave like a feature implementation.

Here is the structure at a high level:

One detail I like here is the disambiguation step. For example, the bug-fix skill first asks whether the issue is actually broken behavior or whether the requirement changed. If it is the latter, Sextant redirects the work to modify-feature instead of pretending it is a bug. That is a small design choice, but it prevents a lot of wasted motion.

3. Different Task Sizes Activate Different Rules

Another thing Sextant does explicitly is treat small and large changes differently.

The same fix-bug skill does not always run with the same rule depth. Instead, the rules that get activated depend on the task size:

• Lightweight: single-function tweaks, config changes, and other narrow edits. These use the baseline rules, anti-pattern detection, and direct execution.
• Medium: module-internal changes or work that introduces new functions or classes. These add checks like SRP, DRY, and interface contract review.
• Large: cross-module changes or public interface changes. These bring in broader checks such as impact analysis and architecture compliance review.

This is not left to vibes. Sextant defines a five-factor Impact Radius Scorecard based on things like files changed, public interface changes, dependency direction changes, data structure changes, and downstream blast radius. That score determines whether the work is treated as lightweight, medium, large, or architectural.

What matters here is not the labels themselves. It is that the rule activation is explicit. Small tasks stay small. Bigger tasks do not get to pretend they are small just because the initial diff looks simple.

4. Principle Conflicts Are Handled as Decisions, Not Vibes

A lot of engineering advice sounds reasonable in isolation.

Keep things DRY. Avoid overengineering. Respect boundaries. Minimize change. Prefer secure choices.

The hard part is when those principles collide.

Sextant makes that collision explicit. Instead of vaguely saying “balance the tradeoffs,” it defines arbitration rules for common conflicts.

A few examples:

• DRY vs YAGNI: if shared logic has only one caller, YAGNI wins.
• OCP vs YAGNI: if an interface has only one implementation, ship the concrete class directly.
• DRY vs Layer Boundaries: if deduplication would cut across boundaries, the boundary wins.
• Baseline vs Minimal Change: if you are fixing a bug and notice nearby baseline issues, minimal change usually wins.
• Security vs Convenience: security wins.

That matters more than it sounds. A lot of AI-generated changes go off track not because the code is syntactically wrong, but because the model does not know which principle should take priority in context. Sextant’s approach is to reduce that ambiguity.

5. Where Sextant Fits Compared with Superpowers and gstack

In the Claude Code skills ecosystem, Superpowers (by Jesse Vincent / obra) and gstack (by Garry Tan) are two well-known frameworks. The comparison is not really about which one is “best.” It is about what kind of work each one is optimized for.

Design Philosophy at a Glance

A table like this can make the differences look cleaner than they feel in real use, but it does help anchor the comparison.

One practical difference is how you get into a workflow. Superpowers and gstack both lean on explicit slash commands, so the user chooses the mode up front. Sextant leans the other way: you describe the task in natural language, and Claude Code matches it to a sub-skill. Neither model is universally better. One gives you more explicit control; the other asks you to remember less while you are already in the middle of debugging or implementation.

The TDD row shows a similar difference in philosophy. Superpowers is prescriptive about test-first development. Sextant treats it as a project-level setting. That is less a question of capability than of taste: should the framework enforce a working style, or adapt to the one the project already uses?

Where Each Framework Shines

This is where the comparison becomes more useful than the feature list. Superpowers makes the most sense when the team wants a structured loop for new work: brainstorm, plan, implement, and keep TDD front and center. gstack is more helpful when the missing piece is not code structure but role coverage — product questions, design feedback, QA flows, and the kind of prompts a solo builder or small team would otherwise have to simulate manually.

Sextant is aimed at a different problem: everyday engineering work inside an existing system. When the codebase already has architecture, module boundaries, compatibility constraints, and a lot of history, what matters most is not brainstorming or role-play. You need the AI to understand the code it is about to change, route the task correctly, and apply checks that match the scope of the change. That is Sextant’s center of gravity.

What Stands Out in Practice

What makes Sextant stand out is not that it tries to do everything. It is that a few decisions are made explicit instead of being left implicit: task-type routing, principle conflict arbitration, confirmation before riskier edits, visible progress during multi-step work, and optional GitNexus acceleration. The architecture-paradigm support is part of the same pattern. A layer violation does not look the same in a backend service, a frontend component tree, or a monorepo, so the framework tries to judge the same principle in context rather than as a flat rule.

6. Why GitNexus Changes the Workflow

One of the more practical parts of Sextant is how well it lines up with GitNexus.

Claude Code fundamentally operates at the text level. It reads files, searches symbols, and traces call chains one hop at a time. That is fine in smaller projects, but it becomes expensive and incomplete in larger codebases.

Three bottlenecks show up quickly:

• grep finds text matches, not relationships
• call-chain tracing becomes hop-by-hop manual exploration
• “what breaks if I change this?” becomes difficult without a global view

GitNexus addresses that by indexing the codebase as a knowledge graph. It parses ASTs, extracts relationships such as calls, imports, and inheritance, stores them in a queryable graph, and exposes tools through MCP. That means the agent can ask relationship-oriented questions directly instead of reconstructing everything from text search.

Just as importantly, the integration is optional.

Sextant checks whether a .gitnexus/ directory exists. If it does, the GitNexus tool guidance is injected. If not, the same workflow falls back to grep and file reading. In other words, GitNexus is an accelerator, not a requirement.

7. What GitNexus Looks Like in Practice

The difference becomes clearer in actual workflows.

Bug Fixing

Without GitNexus, locating root cause means grepping for error keywords, opening files one by one, tracing callers manually, and estimating impact as you go.

With GitNexus, the same step can use graph queries to locate relevant symbols, inspect caller/callee context, trace the execution path, and enumerate affected upstream callers.

The workflow is the same. What changes is how expensive each step is.

New Feature Work

When adding a feature, Sextant wants to understand the existing architecture and find the most relevant reference module.

Without GitNexus, that means browsing directories and inferring from filenames and code.

With GitNexus, the agent can search for semantically related modules, inspect a module’s dependency relationships, and look for existing extension points like strategies, factories, registries, or plugins. That makes the integration decision less speculative.

Migration

For migrations, the job is not just to find direct references to an old API, but to understand the impact scope and migration order.

Without GitNexus, that is mostly grep.

With GitNexus, the agent can query upstream impact and detect circular dependencies that affect sequencing. That lines up directly with Sextant’s leaf-first migration principle.

8. A Real Example: Two Bugs in a C++ Orchestrator

The strongest part of the story is the execution example, because it shows how these ideas play out in an actual bug-fix flow.

The project is a C++ orchestrator for a voice interaction system involving VAD, ASR, TTC, and related components. The user reported multiple issues in orchestrator.cpp, which triggered Sextant’s fix-bug skill.

Step 1: Read First, Then Diagnose

!(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4yqgw86i0443t0pep5jh.png)

Sextant starts by loading the skill, showing the progress block, and reading the relevant file.

!(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/y6wvojm5e23atmblig0u.png)

After analysis, it produces four findings. Two of them are explicitly judged to be not bugs in scope because they are intentional stubs marked for a later task. The other two are treated as real gaps:

• on_asr_result() can transition to PROCESSING even when TTC still indicates CONTINUE_LISTENING
• graceful_shutdown() persists state to the orchestrator’s own database connection, but checkpoints a different SQLite connection instead

That first distinction matters. It shows the system is not simply treating unfinished-looking code as broken code.

Step 2 and Step 3: Ask Before Editing

!(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rubgmgokfual04p6ry1z.png)

For the TTC-related issue, Sextant presents several repair options to the user through an interactive UI, including a recommended option to gate on_asr_result() on the CONTINUE_LISTENING decision.

The important point here is not the exact UI. It is that the fix plan is surfaced before code changes happen. The user sees the root cause, the proposed change shape, and the risk, then confirms the direction. That is the confirmation gate in action.

Step 4: Verify and Report Limits

!(https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dpwmvi8aota4mfhvxhav.png)
After the fixes, Sextant runs boundary validation and summarizes what was verified:

• the TTC gating issue is fixed
• the normal path is unaffected
• the gate acts as a safety net for edge cases
• the correct database is now checkpointed
• the build is clean and no callers are affected

It also explicitly notes what was not covered by automated timing tests, including the <20ms barge-in path and the 5ms AED window.

That kind of verification summary is one of the clearest parts of the example. It is not just “fixed.” It is “fixed, here is what we checked, and here is what still needs real testing.”

9. What the Example Actually Shows

The orchestrator example ends up making the point more clearly than any feature list could.

It shows that Sextant is trying to produce a particular kind of behavior:

1. Read before acting

   Do not jump from symptom to edit.

2. Keep bug fixes small when they should stay small

   In the example, the final changes are narrow and local.

3. Ask before applying non-trivial fixes

   The user sees the plan before the patch lands.

4. Make execution visible

   Progress blocks show what step the workflow is in.

5. Be honest about verification

   Risks and untested edges are called out explicitly.

That is really the best summary of what Sextant is for. It is less about “AI that writes code faster” and more about “AI that changes code with better judgment.”

Installation

# Option 1: Official Claude marketplace
/plugin install sextant@claude-plugins-official

# Option 2: Via GitHub marketplace
/plugin marketplace add hellotern/sextant
/plugin install sextant@mohist-plugins

# Option 3: Team configuration (commit to repo, team gets it on checkout)
# Configure in .claude/settings.json

See the GitHub repository for full installation instructions and documentation.

Closing Thought

Sextant is not presented as a replacement for every other Claude Code framework. Superpowers and gstack solve different problems.

What Sextant is trying to do is narrower and, to me, more grounded: help Claude Code work more reliably inside existing codebases, where architecture, task shape, change scope, and principle conflicts all matter before the first edit is made.

Principles are tools, not chains. The goal is not more process for its own sake. The goal is to make better changes with lower long-term maintenance cost.

If your workflow looks like cd, vim, git push, repeat — you probably spend 90% of your day in a terminal window. But the best terminal-first developers know that a few well-chosen GUI companions can supercharge that workflow without ever pulling you out of the zone.

Here are 7 Mac apps that pair perfectly with a terminal-heavy development style.

1. Warp

The terminal reimagined for modern developers.

Warp is a Rust-based terminal that adds AI command search, block-based output, and collaborative features without sacrificing speed. If you’ve been using the default Terminal.app or even iTerm2, Warp feels like jumping forward a decade. The input editor alone — with proper cursor movement and autocomplete — makes it worth the switch.

🔗 warp.dev

2. Homebrew

The package manager you already have (but might be underusing).

Every terminal developer has Homebrew installed, but most only use it for basics. Brew bundles (brew bundle dump) let you snapshot your entire CLI toolchain into a Brewfile, making fresh setups take minutes instead of hours. Pair it with brew services to manage background processes like Redis and Postgres without touching launchd directly.

🔗 brew.sh

3. Raycast

A keyboard launcher that replaces half your GUI apps.

Raycast is what happens when you build a launcher for people who hate leaving the keyboard. It handles clipboard history, window management, snippet expansion, and has a growing extension store — all invoked with a hotkey. If you’re a terminal person who resents reaching for the mouse, Raycast bridges the gap between CLI efficiency and the GUI things you still need.

🔗 raycast.com

4. TokenBar

Real-time LLM token tracking in your menu bar.

If you’re running AI-assisted workflows from the terminal — Copilot, Claude Code, API calls via curl — your token usage can spiral fast. TokenBar sits in your menu bar and shows exactly what you’re spending across providers in real time. No dashboards to open, no invoices to decode. One glance and you know where your budget stands. At $5 lifetime, it pays for itself the first time it catches a runaway agent.

🔗 tokenbar.site

5. Monk Mode

Feed-level blocking that keeps you in the terminal.

The biggest enemy of terminal flow isn’t a slow build — it’s “let me just check Twitter real quick.” Monk Mode doesn’t block entire apps or websites. It surgically removes the feed from sites like Twitter, Reddit, YouTube, and LinkedIn while leaving search and direct links intact. You can still look up a Stack Overflow answer without getting sucked into an infinite scroll. For $15 lifetime, it’s the cheapest focus investment you’ll make.

🔗 mac.monk-mode.lifestyle

6. Numi

A text-based calculator that thinks like a developer.

Numi lets you type natural-language math — $4,500 / 12 months, 45% of 128GB, today + 3 weeks — and get instant results in a notepad-style interface. It handles unit conversions, currency, time zones, and variables. For quick back-of-napkin calculations while you’re deep in a terminal session, it’s faster than opening python3 and typing print().

🔗 numi.app

7. CleanShot X

Screenshot and screen recording for sharing terminal output.

When you need to share a terminal error, a cool TUI, or a before/after comparison with your team, CleanShot X is unbeatable. It captures scrolling windows, adds annotations, blurs sensitive data, and copies to clipboard — all from keyboard shortcuts. The built-in OCR also lets you grab text from screenshots of terminal output that someone sent you as an image (we’ve all been there).

🔗 cleanshot.com

Wrapping Up

Living in the terminal doesn’t mean ignoring everything else on your Mac. The best setup is a fast terminal at the center with a few focused, lightweight tools filling in the gaps — launching, calculating, tracking costs, staying focused, and sharing output.

What’s in your terminal-first toolkit? Drop your favorites in the comments 👇

Apple Watch has a clever feature called Water Lock. Here’s how it works and how to replicate it on any device.

Water Lock: The Science

When you exit Water Lock mode, the Apple Watch plays a ~165Hz tone through its speaker. This specific frequency causes the tiny speaker diaphragm to oscillate rapidly enough to overcome the surface tension holding water droplets inside the speaker grille.

The result: water gets physically pushed outward through the mesh. You can actually see tiny droplets fly off the watch when this happens.

Why 165Hz?

The 150-200Hz range is the sweet spot because:

• The wavelength matches typical speaker grille cavity dimensions
• It creates optimal diaphragm displacement
• The oscillation is fast enough to break water surface tension
• But gentle enough not to damage the speaker

Replicating This on Any Phone

The same physics applies to any speaker. A free web tool at fixspeaker.com implements a 30-second frequency sweep from 150-200Hz.

Steps:

1. Open fixspeaker.com
2. Turn volume to maximum
3. Press Eject Water
4. Hold the device with speaker facing down
5. Repeat 2-3 times

The Web Audio API Behind It

const ctx = new AudioContext();
const osc = ctx.createOscillator();
osc.type = 'sine';

// Sweep through the effective frequency range
osc.frequency.setValueAtTime(150, ctx.currentTime);
osc.frequency.linearRampToValueAtTime(200, ctx.currentTime + 30);

osc.connect(ctx.destination);
osc.start();
setTimeout(() => osc.stop(), 30000);

The key insight is using a sweep rather than a fixed tone. Different speaker sizes resonate at slightly different frequencies within the 150-200Hz range, so sweeping ensures you hit the optimal frequency for any device.

Results

Tested across iPhone 15, Pixel 8, Samsung S24, MacBook Air:

• Submersion recovery: 1-2 cycles
• Rain/splash: 1 cycle
• Steam/humidity: 2-3 cycles

The next time someone tells you to put your wet phone in rice, show them this instead.

Elegance: Interactive Flower Shader

A sophisticated, interactive visual experience blending high-end editorial design with advanced WebGL techniques. This project features a 3D-distorted floral gallery element powered by Three.js and custom GLSL Shaders.

Three.js #GLSL #Shaders