Amazon Q Developer Export — Chat History, Session Storage, and Architecture Decision Capture

What Amazon Q Developer is

Amazon Q Developer is AWS's unified AI assistant for software development, released in its current form in April 2024 after merging Amazon CodeWhisperer (inline code suggestions) and the developer features of Amazon Q for Business (enterprise AI assistant) into a single product. Available surfaces:

• VS Code extension — inline code suggestions, a Q chat panel, code review, security scanning, and inline transformation suggestions. The most commonly used surface for developers not using JetBrains.
• JetBrains extension — same capabilities in IntelliJ IDEA, GoLand, WebStorm, PyCharm, Rider, and other JetBrains IDEs. Widely used in enterprise Java, Kotlin, and Go shops.
• AWS Console chat — Q Developer is integrated into the AWS Management Console. The chat panel is accessible from any Console page and is context-aware: if you're viewing an IAM policy page, Q Developer can answer questions about that policy. The Console surface is where most AWS-specific architecture deliberations happen.
• Q Developer CLI — a command-line Q chat interface (q chat), useful for terminal-centric workflows. Installed separately as part of the AWS Toolkit CLI.
• AWS Console IDE integrations — Q Developer integrates into AWS Cloud9, CodeCatalyst, and SageMaker Studio Notebooks, extending its surface to those environments.

Pricing tiers

Q Developer Individual (free) provides: limited inline code suggestions per month, Q chat in IDE and Console, security scanning, basic code transformation. Q Developer Pro ($19/user/month) provides: higher usage limits across all features, enterprise-grade data handling (conversations are not used for model training and are processed in isolated compute), and administrative controls for organizations.

How Q Developer stores (and doesn't store) chat sessions

The storage model for Amazon Q Developer chat is the most important thing to understand before relying on it for architecture deliberation. It differs meaningfully from ChatGPT and Claude.

IDE chat sessions — typically ephemeral

When you open the Q Developer chat panel in VS Code or JetBrains and start a conversation, that conversation exists within the IDE session. When you close the IDE and reopen it, the Q Developer chat panel typically starts with an empty conversation — there is no "previous conversations" sidebar equivalent to ChatGPT's left-panel history or Claude's conversation list. This is the most significant difference from standalone AI assistants.

The implication for architecture deliberation: a Q Developer session where you evaluated three database options, worked through trade-offs, and arrived at a decision is gone when the IDE is closed. It cannot be retrieved, exported, or searched. The decision reasoning exists only in your memory and any artifacts the session produced (code changes, comments, documentation you wrote during the session).

Note: IDE extension versions may vary in persistence behavior, and AWS may add history features in future releases. Check the Q Developer release notes for your IDE extension version. But as of mid-2026, persistent conversation history is not a documented feature of the Q Developer IDE extensions.

AWS Console Q chat — more persistent, less documented

The Q Developer chat integrated into the AWS Console appears to retain more conversation history than the IDE panels. The Console Q chat is accessible from the chat icon in the Console header, and it shows previous conversation threads in a sidebar. However, AWS does not document a specific conversation retention period, and there is no self-serve export feature for Console Q chat history. What you can do: while conversations are still visible in the Console Q chat sidebar, copy the text manually before they expire or are cleared.

Why the storage model matters for decision capture

ChatGPT and Claude were designed as persistent conversation platforms from the start: every conversation is saved, searchable, and exportable. Amazon Q Developer was designed as a developer productivity tool integrated into the tools where developers work — the storage model reflects that. The IDE extension prioritizes performance and IDE integration over persistent history. The result is that the export problem for Q Developer is more acute than for ChatGPT or Grok: it's not just that export is unavailable, it's that the source data may already be gone.

What AWS does collect — and the privacy request path

Even though IDE sessions are ephemeral from the user's perspective, AWS processes the conversation through its infrastructure. The data handling depends on the tier:

• Q Developer Individual (free): AWS may use conversation data to improve the service and train models, subject to the AWS Privacy Notice and Q Developer service terms. Conversations are processed through shared infrastructure.
• Q Developer Pro: Conversations are not used for model training. They are processed in isolated infrastructure per the enterprise data handling commitments. AWS does not use Pro-tier conversations for service improvement without explicit opt-in.

For both tiers, AWS retains some log data for operational purposes (API call logs, error logs) as described in the AWS Privacy Notice at aws.amazon.com/privacy.

GDPR data subject access request for Q Developer

EU residents can request their Q Developer conversation data and other personal data AWS holds via a GDPR Data Subject Access Request.

1. Email aws-eu-privacy@amazon.com with the subject "GDPR Data Subject Access Request — Amazon Q Developer Conversation Data".
2. Include: your AWS account ID (found in the AWS Console under your account name in the top-right menu → Account), your name, the email address associated with your AWS account, a description of the specific data requested (Amazon Q Developer chat history and associated personal data), the legal basis (GDPR Article 15 right of access, Article 20 right to data portability), and your preferred format (JSON or structured machine-readable format).
3. Attach identity verification documentation — government-issued ID or similar.
4. AWS is required to respond within 30 calendar days. Complex requests may be extended to 90 days with notification.

Non-EU users: submit via the AWS Privacy Contact form at aws.amazon.com/compliance/privacy-contact. CCPA requests from California residents are also processed through this channel.

What to expect in the response

Given that Q Developer IDE sessions are ephemeral, the data AWS holds about your Q Developer usage may be more limited than what a DSAR for ChatGPT or Claude would return. You may receive: API call metadata (timestamps, model versions used, token counts), error logs, account activity records. You may not receive full conversation text if AWS's retention policy for Q Developer chat sessions is shorter than the time since the session occurred. The DSAR is worth submitting for recent conversations (within the last 30 days), but for older architecture deliberations, the data may not be available for AWS to return.

Manual capture during a Q Developer session — ranked by durability

The only reliable way to preserve reasoning from Q Developer sessions is to capture during the session. After the IDE is closed, the window closes.

1. Copy-paste to a decision log during the session (most durable)

While the Q Developer chat panel is still open in the IDE, select the relevant conversation turns — the section where you named options, worked through trade-offs, and arrived at a recommendation — and paste them into a decision log file. Create a directory in your project: docs/decisions/, and write a file named with the date and topic: 2026-06-04-rds-vs-aurora-selection.md. Paste the Q Developer conversation text into the file, then add the final decision as a structured summary.

This is a habit, not a tool feature. The habit is: before closing any Q Developer session where you deliberated something with lasting consequences, paste the key exchange into the decision log. Three minutes of capture at the end of the session prevents the "why did we choose this?" question from being unanswerable six months later.

2. Export the session from the Q Developer panel (if available in your extension version)

Some versions of the Q Developer VS Code and JetBrains extensions include a save or export option for the current chat session. Check the Q Developer panel for a "Save conversation" or "Export transcript" option in the panel menu (the three-dot or gear icon in the Q chat panel header). If available, this produces a text file with the session content that can be saved to your decision log directory. This feature availability varies by extension version — check your extension's release notes or changelog for the Q Developer VS Code extension at marketplace.visualstudio.com.

3. AWS Console Q chat copy-paste (for Console-based sessions)

For conversations held in the AWS Console Q chat (the most common surface for AWS-specific architecture deliberations — service selection, IAM design, CloudFormation architecture), the conversation is visible in the Console chat sidebar. While the conversation is visible, copy the relevant turns to a text file. The Console Q chat is more likely to retain sessions across browser restarts than the IDE panels.

4. Record the decision outcome and rejected alternatives in a commit message or PR description

Even if the full conversation text is lost, the decision outcome can be captured in git as part of the commit or PR that implements it. A PR description that includes: "Chose Aurora Serverless v2 over RDS Multi-AZ — Aurora Serverless fits our variable load pattern better (Q Developer session confirmed the cost model at our traffic shape: ~40% savings vs RDS at our P95 traffic), RDS was rejected because the manual scaling overhead for our unpredictable batch jobs was explicitly flagged as a risk during the architecture review" — is a meaningful decision record even without the full conversation text.

This is a lower-fidelity record than the full conversation, but it is better than nothing and it lives in git with the code. When a new engineer runs git log --oneline and finds the commit that introduced the Aurora configuration, the PR description with the decision rationale is three clicks away.

When Q Developer conversations matter most for decision extraction

Not all Q Developer sessions are equally decision-rich. These are the highest-priority capture targets:

AWS service selection decisions

Q Developer's most distinctive capability compared to ChatGPT and Claude is its deep AWS-specific knowledge: current service pricing, service limit defaults, known integration patterns, and the subtle differences between services that appear similar on the surface (EventBridge vs SNS vs SQS; RDS vs Aurora vs DynamoDB for a given workload; ECS vs EKS for a particular team's constraints). A Q Developer session deliberating an AWS service selection decision contains context that a ChatGPT or Claude session would require significant prompt engineering to replicate. The rejection reasons Q Developer surfaces ("SQS doesn't support message ordering at scale without FIFO queues, which add 10x cost at your projected volume") are AWS-specific and not easily reconstructed from memory.

IAM and security architecture decisions

IAM policy design decisions made in Q Developer sessions often contain the rejected alternatives — broader permission sets that were considered and narrowed, trust policies that were evaluated and changed — that are invisible once the final policy is committed to Terraform or CloudFormation. The reasoning behind a least-privilege policy is precisely the kind of architecture decision that shows up in a security audit two years later ("why does this role have s3:GetObject on * instead of the specific bucket ARN?") with no documented answer.

Infrastructure architecture decisions with cost implications

Q Developer sessions that evaluate infrastructure options often include cost analysis: instance sizing trade-offs, NAT Gateway vs NAT instance for a given traffic volume, multi-region vs single-region with cross-region replication. The cost projections surfaced in a Q Developer session reflect the workload context you provided during the conversation — context that is hard to reconstruct six months later when the architecture decision is being reviewed. Capturing the cost comparison from the Q Developer session makes future architectural reviews faster and more grounded.

Amazon Q Developer vs other AI coding assistants — export coverage comparison

The pattern for IDE-first AI coding assistants (GitHub Copilot and Amazon Q Developer) is consistent: designed as productivity tools in the IDE, not as persistent conversation platforms, and without the bulk export features that standalone AI assistants provide. For preserving architecture reasoning, the implication is the same: capture during the session via manual copy-paste. The difference between Q Developer and Copilot is that Q Developer's AWS-specific knowledge makes the session content more decision-rich for AWS architecture deliberations — and therefore more worth capturing.

Using the WhyChose extractor with manually captured Q Developer content

The WhyChose open-source extractor natively processes ChatGPT and Claude conversations.json export files. For Amazon Q Developer sessions captured via copy-paste, the extractor accepts plain text input: paste the Q Developer conversation into a .txt file and pass it to the extractor. The decision-extraction patterns (vs-phrase detection, trade-off markers, rejection indicators) work on plain text, not just on JSON — the structured JSON format from ChatGPT and Claude exports improves accuracy, but the core extraction logic runs on text content.

For organizations using both ChatGPT/Claude and Amazon Q Developer: run the quarterly extraction workflow on the ChatGPT and Claude exports (the structured JSON path) to get the decisions from those tools, and maintain a manual copy-paste habit for Q Developer sessions to capture the AWS-specific architecture decisions that Q Developer is particularly valuable for. The two workflows complement each other — you don't lose the Q Developer reasoning just because it doesn't have a JSON export path.