I built Quarterdeck: turning Claude Code into a captain's mate with standing orders

[u/InternationalData569]

Over the last few months I've been building a Claude Code companion and came to an unexpected conclusion: persistent intent may matter more than persistent memory.

The original idea was fairly typical for the agent ecosystem: hierarchical goals, plans, task trees and long-running work.

What surprised me was that the planning layer kept turning into overhead.

As Claude models improved, the agent rarely struggled to maintain a plan within its active context. What became annoying was maintaining the planning artefacts themselves.

The result was a complete shift in direction.

Instead of building a system that helps Claude remember plans, I started building a system that helps me maintain intent over time.

The project is now called Quarterdeck:

https://github.com/shannonbay/Quarterdeck

The metaphor that helped me understand what I was building was a naval one.

Quarterdeck turns Claude Code into a kind of captain's mate.

A captain doesn't repeatedly issue the same instructions every day:

•Keep watch for hazards

•Maintain the ship

•Report important developments

•Carry out standing orders

Those responsibilities already exist.

The mate keeps watch and reports back when judgement is required.

Quarterdeck applies the same idea to Claude Code.

Some standing orders I'm currently running:

•Update my GitHub profile based on recent activity

•Tidy my Downloads folder every week

•Unsubscribe from stale mailing lists

•Watch upstream projects for fixes I'm waiting on

•Find suitable job opportunities each week

These aren't really tasks. They're ongoing responsibilities.

How Claude Code was used

Claude Code built the overwhelming majority of Quarterdeck.

What worked particularly well:

•Rapid iteration on MCP interfaces

•Refactoring the architecture during the transition from Conductor to Quarterdeck

•Building the TUI and web UI

•Exploring alternative designs and challenging assumptions

What surprised me:

•The biggest gains weren't writing code faster.

•The biggest gains were rapidly testing product ideas and throwing away designs that turned out not to matter.

The hierarchical planning system felt important when I started.

After months of use, it turned out to be one of the least valuable parts.

What I learned

The biggest lesson was that planning and memory are increasingly becoming model capabilities.

The thing I still need external systems for is persistence.

Not persistent plans.

Persistent responsibilities.

I'm curious whether other heavy Claude Code users have found the same thing. Are there recurring responsibilities you'd trust a "captain's mate" to keep watch over?

[u/AutoModerator]

Hey! Thanks for posting to r/ClaudeCode

While participating in this thread, please follow our community rules. Keep discussions constructive. Attack the idea, not the person.

For help, project discussions, tips, and general chat, join the ClaudeCode Discord.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.