DEV Community: Echo

Treat AI coding sessions as project infrastructure

Echo — Mon, 01 Jun 2026 22:36:35 +0000

Most AI coding workflows treat the current session as the important part.

That makes sense while you are in the loop. You ask Claude Code to inspect a tricky bug, or you queue Codex to write a PR, and the useful context is right there in front of you.

The problem starts a week later.

You remember that one session found the exact migration edge case. You remember another one explained why the quick fix was wrong. You might even remember the project. But you do not remember the session ID, the terminal tab, or the exact prompt that got you there.

That is the point where AI coding sessions stop being conversations and start becoming project infrastructure.

Here is the split that has worked best for me.

1. Keep durable rules in project files

Files like AGENTS.md, CLAUDE.md, or .codex/rules are good for behavior that should apply every run:

coding style
test expectations
release rules
known architecture constraints
commands that should or should not be used

This is not session history. It is the baseline contract for the project.

If you correct the agent twice on the same pattern, that correction probably belongs in one of these files.

2. Keep active work in a handoff document

For a feature or refactor, I like having a short implementation.md or handoff.md.

It should answer a few boring questions:

what are we changing?
what phase are we in?
what did the last agent already try?
what still needs human review?
what tests were run?

This works especially well when Claude Code and Codex are both touching the same repo. Claude Code can help explore and make decisions locally, while Codex can take a narrower task and return a PR. The handoff document keeps those runs from drifting apart.

3. Treat old sessions as searchable project records

The raw transcripts usually exist somewhere. For Claude Code, that often means digging through local session files. For Codex, the useful context may be split across tasks, PR notes, and local terminal work.

The hard part is not that the data is gone.

The hard part is finding the right old conversation when you only remember the project and the decision.

That is why I ended up building Shelf: a small open-source desktop app for browsing Claude Code and Codex sessions by project.

Repo: https://github.com/Harukaon/shelf

The goal is simple: old AI coding sessions should be reopenable without remembering opaque session IDs or spelunking through terminal history.

It is built with Tauri v2, Rust, TypeScript, Vite, and xterm.js, and currently targets macOS Apple Silicon and Linux.

My current rule of thumb

If it affects every future run, put it in project rules.

If it affects the current feature, put it in a handoff doc.

If it explains why a past decision happened, make sure the old session is easy to find again.

That third bucket is easy to ignore until you have twenty sessions across the same project. After that, retrieval becomes part of the workflow.

AI coding sessions are not just chat logs. They are project history.

A practical way to keep AI coding sessions from becoming disposable

Echo — Mon, 01 Jun 2026 19:13:08 +0000

AI coding tools make it easy to generate code, but they also create a quiet documentation problem: useful reasoning gets trapped inside sessions that are hard to find later.

The most useful parts of an AI session are often not the final patch. They are the dead ends, assumptions, trade-offs, and test ideas that led to the patch.

A few practices that help:

Start sessions from the correct project folder.
Name work around the task, not the model: auth-timeout-fix, migration-plan, release-checklist.
Keep important prompts and decisions close to the repo.
Review old sessions before asking the model to solve a similar bug again.
Treat session recovery as part of your dev environment, like restoring editor tabs.

I have been building this workflow into an open-source desktop app called Shelf.

Shelf is not another coding model. It is a small Tauri desktop workspace manager for people who use Claude Code and Codex across multiple repos.

The current version can:

organize sessions by project
resume previous Claude Code and Codex sessions
scan local AI conversation history
restore workspace state after restart
keep file tree + real PTY terminal in the same window

The main idea is simple: AI coding history should be browsable, not disposable.

Repo: https://github.com/Harukaon/shelf

Related: I also wrote a short workflow note on organizing Claude Code and Codex sessions across projects: https://dev.to/uzoma_uche_3ec83974b4a8a5/organizing-claude-code-and-codex-sessions-across-projects-722

Organizing Claude Code and Codex sessions across projects

Echo — Mon, 01 Jun 2026 18:49:37 +0000

I keep bouncing between Claude Code and Codex while working on different repos. The annoying part is not the AI assistant itself. It is remembering which terminal, project, and conversation belongs to which task after a restart or a long break.

A workflow that has helped me:

Keep one workspace per repo, not one giant terminal pile.
Name sessions around the task, not the tool: fix-auth-tests, refactor-importer, release-notes.
Review old AI sessions before starting a similar task. There is often useful context hiding in previous prompts and patches.
Treat session recovery as part of the dev environment, like restoring editor tabs.

I have been working on an open-source desktop app around this exact workflow: Shelf.

It is a Tauri app for managing Claude Code and Codex workspaces in one window. The main things it does are:

group AI coding conversations by project
reopen previous sessions without remembering session IDs
scan and organize conversations automatically
keep a file tree and real PTY terminal next to the session list
restore workspace state after restarting

It is still early, but active. The current release is v0.2.18 and it supports macOS Apple Silicon and Linux.

The part I care about most is reducing the small bits of friction that make AI coding sessions feel disposable. If the context from yesterday is easy to find, it is much easier to continue the work instead of asking the model to rediscover everything.

Repo: https://github.com/Harukaon/shelf