3 Tools That Changed How We Code With AI Agents

AI coding agents have evolved from glorified autocomplete into genuine development partners. But raw model intelligence alone does not ship software. The real breakthroughs in March 2026 came from three tools that solve the structural problems of agentic coding: how to structure agent workflows, how to steer agents mid-task, and how to give agents persistent memory across sessions.

Here are the three AI coding tools that fundamentally changed our development workflow — and how you can start using them today.

1. Superpowers: The Skill Framework That Makes Agents Follow a Process

The biggest problem with AI coding agents is not capability — it is discipline. Hand an agent a feature request, and it will start writing code immediately. No spec. No tests. No plan. Superpowers, created by Jesse Vincent at Prime Radiant, solves this by intercepting agent sessions at startup and loading mandatory behavioral guides called "skills."

How Superpowers Works

When you fire up Claude Code, Cursor, or any supported coding agent with the Superpowers framework installed, the agent does not jump into code. Instead, it follows a structured development methodology:

1. Brainstorming — The agent asks what you are really trying to build. It refines the idea through Socratic questions, explores alternatives, and presents the design in sections short enough to actually read.
2. Git Worktrees — After design approval, it creates an isolated workspace on a new branch, runs project setup, and verifies a clean test baseline.
3. Planning — It breaks work into bite-sized tasks (2-5 minutes each). Every task has exact file paths, complete code snippets, and verification steps. The plan is written "for an enthusiastic junior engineer with poor taste, no judgment, and an aversion to testing."
4. Subagent-Driven Development — Each task gets dispatched to a fresh subagent with two-stage review: first spec compliance, then code quality.
5. Test-Driven Development — Strict RED-GREEN-REFACTOR. The framework will delete code written before tests. No exceptions.
6. Code Review — Reviews against the original plan, reports issues by severity. Critical issues block progress.
7. Branch Finishing — Verifies all tests pass, presents options (merge, PR, keep, or discard), and cleans up the worktree.

Why This Matters for AI Coding

The key insight of the Superpowers skill framework is that these are mandatory workflows, not suggestions. The agent checks for relevant skills before any task. Jesse Vincent reports that agents running Superpowers can work autonomously for hours without deviating from the plan.

The Superpowers framework is available as a Claude Code plugin, a Cursor extension, and supports manual setup for Codex, OpenCode, and Gemini CLI. It is MIT-licensed and trending on GitHub as of March 2026.

At Context Studios, we see a clear parallel between the Superpowers skill architecture and OpenClaw's skill system — both use composable SKILL.md files that auto-trigger based on context. The difference is scope: Superpowers focuses exclusively on coding workflows, while OpenClaw's skills cover everything from browser automation to IoT control.

2. Claude Code Loops: Steering Agents Without Breaking Flow

Claude Code received massive updates in March 2026 (versions 2.1.63 through 2.1.77), but two features stand out for agentic coding workflows: /loop for recurring tasks and /btw for side questions.

The /loop Command: Lightweight Cron in Your Terminal

Introduced in Claude Code v2.1.71, the /loop command transforms Claude Code into a recurring monitoring system. Define an interval and a prompt, and Claude executes it automatically:

• /loop 5m check the deploy — checks deployment status every 5 minutes
• /loop 30s run tests — runs tests every 30 seconds during development
• /loop 1h check for new issues — monitors GitHub issues every hour

Loops are session-scoped with a three-day expiry. They stop when the session closes, keeping things lightweight. You can disable them with the CLAUDE_CODE_DISABLE_CRON environment variable if you need a clean session.

As Sean Kochel explains in his detailed walkthrough, loops are particularly powerful for test-driven development workflows. Set up a /loop 30s run tests and write your code — the agent continuously validates your changes against the test suite in real time. Combined with Superpowers' strict TDD methodology, this creates a feedback loop where code is verified every 30 seconds without manual intervention.

The /btw Command: Side Questions Without Derailing Context

The /btw command, built by Erik Schluntz on the Claude Code team, solves a genuine pain point. When Claude Code is mid-task — say, refactoring a large module — and you need to ask a quick question, you previously had two bad options: cancel the response and lose progress, or wait until it finishes.

/btw lets you ask a side question while Claude is still processing. The response does not get added to the conversation history, so it does not pollute the context window or change what Claude "remembers" about your session.

Key characteristics of the /btw command:

• Single response only — no follow-ups within a /btw thread
• No tool access — it answers from conversation context only
• Low cost — it reuses the prompt cache, so token usage is minimal
• Dismiss with Space, Enter, or Escape and continue working

Thariq Shihipar (Claude Code lead) announced /btw on March 11, 2026, and the tweet reached 2.2 million views — a clear sign of how badly developers needed this feature. The mental model: /btw is the inverse of a subagent. A subagent has full tool access but starts with an empty context. /btw has full visibility into your current conversation but has no tools.

Practical Loop Patterns for AI Agent Coding

Here are three Claude Code loop patterns we use regularly:

1. TDD Guardian: /loop 30s run tests during active development. Any test regression triggers immediate notification.
2. Deploy Monitor: /loop 2m check CI status after pushing a PR. Get instant feedback without switching to the GitHub UI.
3. Code Quality Watch: /loop 10m lint and report issues for ongoing quality monitoring during large refactors.

3. Claude Code + Obsidian: Persistent Memory for AI Coding Agents

The third tool addresses a fundamental limitation of AI coding agents: memory loss. Every new Claude Code session starts fresh. The agent has no idea what you worked on yesterday, what architectural decisions you made, or what mistakes it should avoid. WorldofAI and Greg Isenberg both published tutorials on this approach in March 2026, validating what many developers have been building independently.

The Memory Problem in Agentic Coding

Without persistent memory, AI coding agents repeat the same mistakes across sessions. They suggest patterns you explicitly rejected. They forget project conventions. They lose context on why certain decisions were made. This is not just annoying — it is expensive. Rebuilding context at the start of every session burns tokens and developer time.

How Claude Code + Obsidian Solves It

The solution uses MCP (Model Context Protocol) servers to connect Claude Code to a local Obsidian vault. The agent can read and write notes, search across the knowledge base, and maintain a persistent record of:

• Architectural decisions — why you chose Next.js over Remix, why the API uses REST instead of GraphQL
• Project conventions — code style preferences, naming conventions, file structure rules
• Lessons learned — bugs that were hard to diagnose, performance pitfalls, API quirks
• Task context — what was done, what is in progress, what is blocked

The setup is straightforward:

1. Install an Obsidian MCP server (several community options exist)
2. Configure Claude Code to use the MCP server
3. Create a vault structure for agent memory (we recommend separate folders for decisions, conventions, and session logs)
4. The agent automatically reads relevant notes at session start and writes new learnings at session end

Beyond Obsidian: The Memory Architecture Spectrum

The Claude Code + Obsidian approach works because Obsidian is just Markdown files — no proprietary format, no lock-in, fully version-controllable with git. But it is one point on a broader spectrum of AI agent memory solutions:

At Context Studios, we built Cortex — a cognitive memory system with multi-store architecture, decay functions, and spreading activation — because our agents need more than note-taking. They need memory that fades, consolidates, and surfaces relevant context automatically. But for most developers starting with AI agent memory, Claude Code + Obsidian hits the sweet spot of simplicity and power.

How the Three Tools Work Together

These three AI coding tools are not competing alternatives — they are complementary layers of an effective agentic coding stack:

1. Superpowers provides the structure — mandatory workflows that keep agents disciplined through planning, TDD, and code review
2. Claude Code Loops provide the iteration — /loop for continuous feedback and /btw for steering without context pollution
3. Claude Code + Obsidian provides the memory — persistent knowledge that survives session boundaries

Together, they address the three biggest complaints developers have about AI coding agents: agents that wing it instead of planning (Superpowers fixes this), agents that cannot be steered mid-task (loops and /btw fix this), and agents that forget everything between sessions (Obsidian memory fixes this).

A Typical Agentic Coding Session in 2026

Here is what a productive session looks like with all three tools:

1. Claude Code starts and loads your Obsidian memory — it knows the project context, past decisions, and your coding conventions
2. Superpowers activates and asks what you want to build
3. After brainstorming and plan approval, subagents start executing tasks
4. You set /loop 30s run tests for continuous TDD feedback
5. Mid-task, you use /btw to ask "what was the API rate limit we decided on?" — the agent answers from context without losing its place
6. When the work is complete, architectural decisions and lessons get written back to Obsidian
7. Next session, the agent picks up exactly where you left off

Getting Started

Here is how to set up each tool:

Superpowers Skill Framework

# Claude Code
/plugin install superpowers@claude-plugins-official

# Cursor
/add-plugin superpowers

# Gemini CLI
gemini extensions install https://github.com/obra/superpowers

Claude Code Loops

# Built-in — just use it
/loop 5m check deploy status
/btw what was the error message earlier?

Claude Code + Obsidian Memory

# Install an Obsidian MCP server
npm install -g obsidian-mcp-server

# Configure in Claude Code settings
# Add MCP server connection to your local Obsidian vault

Definition of Done

If you are evaluating these tools for your team, here is what "working well" looks like:

• Agents follow a plan before writing code (Superpowers)
• Tests run automatically during development (/loop)
• Quick questions do not derail long tasks (/btw)
• Architectural decisions survive between sessions (Obsidian)
• Code review happens before merge, not after (Superpowers)
• Context rebuilding time drops from minutes to seconds (Obsidian)

FAQ

What is the Superpowers skill framework for AI coding agents?

Superpowers is an open-source framework by Jesse Vincent that enforces structured development workflows on AI coding agents. It loads mandatory "skills" — brainstorming, planning, TDD, code review — that the agent must follow before writing code. Available for Claude Code, Cursor, Codex, OpenCode, and Gemini CLI.

How does the /loop command work in Claude Code?

The /loop command creates recurring tasks within a Claude Code session. You specify an interval and a prompt (e.g., /loop 5m run tests), and Claude executes it automatically. Loops are session-scoped with a three-day expiry and stop when the session closes. Introduced in Claude Code v2.1.71 in March 2026.

What is /btw in Claude Code and how does it save tokens?

/btw lets you ask a side question while Claude Code is processing another task. The response is not added to conversation history, keeping your context window clean and reducing token usage. It has no tool access — it answers from existing context only. Built by Erik Schluntz, announced on March 11, 2026.

How do you connect Claude Code to Obsidian for persistent memory?

You use an MCP (Model Context Protocol) server that bridges Claude Code to a local Obsidian vault. The agent can read project decisions, conventions, and session logs from Obsidian notes, and write new learnings back. This gives agents persistent memory across sessions without proprietary formats.

Can these three tools be used together?

Yes — they are designed to be complementary. Superpowers provides workflow structure, Claude Code loops provide iteration and steering, and Obsidian provides persistent memory. Together they solve the three core problems of agentic coding: lack of discipline, lack of steering, and lack of memory.

Are these tools free to use?

Superpowers is MIT-licensed and free. Claude Code loops and /btw are built into Claude Code (requires a Claude subscription — Pro, Max, Team, or Enterprise). Obsidian is free for personal use, and community MCP servers are open-source. The only cost is your Claude API or subscription plan.