<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Swaraj Biswal</title>
    <description>The latest articles on DEV Community by Swaraj Biswal (@swaraj_42).</description>
    <link>https://dev.to/swaraj_42</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4249253%2F2395df34-3288-452a-b083-48b6abc80148.jpg</url>
      <title>DEV Community: Swaraj Biswal</title>
      <link>https://dev.to/swaraj_42</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/swaraj_42"/>
    <language>en</language>
    <item>
      <title>Can we make any use of agent sessions ?</title>
      <dc:creator>Swaraj Biswal</dc:creator>
      <pubDate>Tue, 17 Nov 2026 12:50:37 +0000</pubDate>
      <link>https://dev.to/swaraj_42/can-we-make-any-use-of-agent-sessions--32mo</link>
      <guid>https://dev.to/swaraj_42/can-we-make-any-use-of-agent-sessions--32mo</guid>
      <description>&lt;p&gt;I've seen developers implement a feature using Claude Code or Codex, finish the implementation, close the session, and move on to the next thing.&lt;/p&gt;

&lt;p&gt;When something breaks later, they open an entirely new session, ask the coding agent to inspect the codebase, find the bugs, and suggest fixes. The previous session, where the feature was actually implemented, rarely enters the picture.&lt;/p&gt;

&lt;p&gt;I find this workflow interesting because the original session contains something that the current codebase might not: &lt;strong&gt;the history of how a particular change came into existence.&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;I have a theory that agent sessions can be much more useful than we currently give them credit for. They might be the only concrete evidence of what actually happened during development.&lt;/p&gt;

&lt;p&gt;Think about what's inside a session:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Part&lt;/th&gt;
&lt;th&gt;What it tells you&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Prompt&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;What you actually asked for&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Reasoning&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Why the agent chose one approach over another&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Tool calls&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Each file read, edit, and shell command&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Output&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Test results, errors, and stack traces&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Dead ends&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Approaches it tried and eventually abandoned&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Our diffs show the final result. The session gives us a record of how we got there.&lt;/p&gt;

&lt;h2&gt;
  
  
  Why I think this matters
&lt;/h2&gt;

&lt;p&gt;We've all seen those familiar phrases emitted from coding agents:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Implemented the feature successfully."&lt;/li&gt;
&lt;li&gt;"All 157 tests passed."&lt;/li&gt;
&lt;li&gt;"No linting or type errors found."&lt;/li&gt;
&lt;li&gt;"Verified that the existing functionality remains unaffected."&lt;/li&gt;
&lt;li&gt;"No regressions detected."&lt;/li&gt;
&lt;li&gt;"All edge cases have been handled."&lt;/li&gt;
&lt;li&gt;"The implementation is complete and ready for review."&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;But how much should we actually trust them ?&lt;/p&gt;

&lt;p&gt;There can be Silent bugs, failed approaches, removing a features to implement a new feature and questionable decisions somewhere in the implementation process itself. Sometimes, these issues could have been caught much earlier if someone had looked at what actually happened during the session.&lt;/p&gt;

&lt;p&gt;A fresh debugging session can inspect the current codebase state, but it doesn't necessarily know what the previous agent tried, which errors it encountered, what it failed to resolve, or what decisions were made along the way.&lt;/p&gt;

&lt;h2&gt;
  
  
  Some ways we could use agent sessions
&lt;/h2&gt;

&lt;p&gt;&lt;strong&gt;1. Reviewing PRs&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;As I mentioned in the start, Code changes behind AI Agent-generated PRs and commits can get huge. Instead of reverse engineering thousands of lines of diff without context, having access to the sessions behind them gives us the exact intent of what was requested, what the agent changed on its own, and why certain decisions were made.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;2. Verifying what the agent claims&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Did the agent actually followed the instructions? Did it actually run the tests? What was the output? Did it encounter errors and move on without addressing them?&lt;/p&gt;

&lt;p&gt;The session gives us a way to investigate these claims rather than relying entirely on the final response or generated summaries. Obviously because sessions tells us what the Agent did not what it claims.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;3. Sharing context with teammates&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When someone else picks up a piece of work, having access to what was already tried, what failed, and why a particular approach was chosen can save a lot of repeated effort.&lt;/p&gt;

&lt;p&gt;A generated summary is like the one time Knowledge transfer an angry unpaid intern would give after their term gets over, which will only add you up a lot more overhead. The Sessions allows you see through time with all the actions snapshots.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;5. Understanding our own workflow&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;Going through older sessions can also reveal patterns in how we work.&lt;/p&gt;

&lt;p&gt;For example, vague prompts like "clean this up" can lead to sprawling changes, while more specific instructions tend to produce focused implementations.&lt;/p&gt;

&lt;h2&gt;
  
  
  Obviously it is not that simple
&lt;/h2&gt;

&lt;p&gt;Agent sessions aren't particularly convenient to work with.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;They're scattered:&lt;/strong&gt; Claude Code, Codex, and other tools store sessions in different locations and formats.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They're huge:&lt;/strong&gt; A single session can contain thousands of lines of JSON.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They're expensive to revisit:&lt;/strong&gt; Feeding an entire session back into an agent can quickly consume its context window.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;They don't necessarily stick around:&lt;/strong&gt; Some tools have automatic transcript cleanup policies.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Multiple Agent session behind a contribution:&lt;/strong&gt; It is possible that multiple agent sessions were used for a PR or commit with a major feature change.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;So, while there's a lot of useful information in these sessions, accessing and navigating it is still a crazy amount of pain.&lt;/p&gt;

&lt;p&gt;I've been exploring ways to make this information easier to browse and reuse, particularly when working across different agents and collaborating with other developers.&lt;/p&gt;

&lt;p&gt;But I'm more interested in hearing what you people think.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Do you revisit your Claude Code, Codex, or other coding agent sessions after implementing a feature?&lt;/strong&gt;&lt;/p&gt;

&lt;p&gt;When debugging, do you ever look at the original implementation session, or do you usually start fresh and let the agent figure things out from the codebase?&lt;/p&gt;

&lt;p&gt;And more importantly, do you think agent sessions should be treated as part of a project's development history?&lt;/p&gt;

</description>
      <category>ai</category>
      <category>agents</category>
      <category>vibecoding</category>
      <category>debugging</category>
    </item>
  </channel>
</rss>
