# Why a One-Line Change Can Break Your Whole Stack - Cole Gannaway, Qodo

Cole Gannaway, Qodo

[Talk page](https://ai.engineer/talks/YqxpPI7YUjE-why-one-line-change-break-your-whole) · [Video](https://www.youtube.com/watch?v=YqxpPI7YUjE)

## Why a One-Line Change Can Break Your Whole Stack

Passing builds and unit tests can leave downstream consumers unchecked. Cole Gannaway’s Qodo walkthrough follows a Bitwarden data-model rename through repository dependencies, reusable review rules, independent review agents, and checks against the original ticket.

![Recording frame at 2:03: Why a One-Line Change Can Break Your Whole Stack](https://ai.engineer/api/talk-essay-media/c3071d66b3618db26eb68fc76711061d6760ba5a4053c0286e9bc7432c89bef1)

Why a One-Line Change Can Break Your Whole Stack — recording at 2:03

### When review becomes the bottleneck

[0:12](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=12s)

Teams can generate code faster and still struggle to get it through review. Cole Gannaway, a solutions engineer at Qodo, describes customers who want a software factory that takes work from a ticket all the way to production. Their pull requests become the bottleneck: implementation accelerates, while deciding whether the resulting change is trustworthy remains difficult.

Qodo focuses on that review stage, supplying context to the human or agent making the decision. It occupies one part of the larger ticket-to-production workflow. Code generation still makes mistakes, and faster generation makes it more urgent to understand the consequences of a proposed change before approving it.

To see why an ordinary review can look reassuring, consider Gannaway’s illustrative example from Bitwarden, the open-source password manager. A developer wants a rename and changes one line of its data model. In the imagined approval decision, the build passes, the unit tests pass, and perhaps the linters pass too. The edit matches the developer’s intention, so approving it feels reasonable.

![Recording frame at 2:39: When review becomes the bottleneck](https://ai.engineer/api/talk-essay-media/21a9d1dfdb5d558e0bc845d50ca3e32124abc5200e62c12c11b6723beccdbf1a)

When review becomes the bottleneck — recording at 2:39

The familiar verdict is “seems good to me.” Gannaway’s show-of-hands question surfaces the compromise behind it: reviewers sometimes merge without reading every changed line, depending on their tools for confidence. The scope of those tools’ context then becomes part of the review decision.

### Map the components that depend on the change

[3:34](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=214s)

The missing question is what else depends on the changed model. In the Bitwarden scenario, the back-end server can connect to web clients, mobile or iOS clients, MCP servers, and command-line clients. A rename can become a compatibility problem when a consumer still expects the previous model. The server’s checks can look healthy while the effect appears elsewhere, perhaps as a production bug report or a crashing web application.

To understand which connections matter, a reviewer needs more detail than a line joining two repository names. Qodo’s [cross-repository review](https://docs.qodo.ai/governance/cross-repo-code-review) uses an automatically built software graph and an integration surface: the actual components through which repositories connect. Knowing that Bitwarden server connects to Bitwarden Android identifies a relationship; knowing which components connect makes it possible to assess whether that relationship matters to the edited model.

![Recording frame at 3:43: Map the components that depend on the change](https://ai.engineer/api/talk-essay-media/d18409f5ed50e4c1ead15baf31a14f77a09157b43cf5af395f689857620f933e)

Map the components that depend on the change — recording at 3:43

The graph lets the human or review agent widen its investigation from the edited repository to the affected consumers. That is the reason to map the system at component level: a small diff can reach several clients in other repositories, even when the local change looks correct. The relevant measure of impact is how far the change reaches through those connections.

### Put API rules in place before generation

[4:56](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=296s)

Dependencies are part of what experienced reviewers contribute. They also bring conventions, taste, and memories of earlier mistakes. If that knowledge stays with a senior engineer, the same person may need to recognize and explain the same problem on every review. Custom rules make some of that judgment available to subsequent reviewers.

![Recording frame at 6:13: Put API rules in place before generation](https://ai.engineer/api/talk-essay-media/0f1aa6121cf8960d4397bc20bb9d9f590efe7485a1ca0bc42193949e88799b47)

Put API rules in place before generation — recording at 6:13

Gannaway suggests adding a deprecation flag or reviewing a public API change more closely. The rule on screen is more specific. Public API fields are additive, and an existing field must be deprecated before it is renamed or removed. In the example, the coding agent plans to keep RevisionDate and add LastModified, so clients that still read the old field can continue to do so.

The same information can influence implementation before there is anything to review. In the example, an MCP server brings Codebase Wisdom, custom rules, and accumulated team knowledge into the coding agent before code generation. The agent can consider downstream effects while choosing the change, rather than learning about them only after opening a pull request. This improves the opportunity to get the first attempt right; Gannaway still calls for a later check.

### Give the reviewer its own context and judgment

[6:17](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=377s)

An implementation agent such as Claude Code already has useful background, which makes asking it to review its own work an appealing shortcut. The case for a separate review agent has two parts: controlling what occupies its context window and reducing the chance that it repeats the implementer’s blind spots.

![Recording frame at 7:10: Give the reviewer its own context and judgment](https://ai.engineer/api/talk-essay-media/45592ed8fb37494065252cf1972f1e9f47a5e4dba11fc85337a315ce5a1ee57b)

Give the reviewer its own context and judgment — recording at 7:10

- **Context devoted to review:** The implementation agent spends context on debugging, implementation, and exploring the codebase. A review agent can concentrate on Codebase Wisdom, the software graph, and information specific to this review. Larger windows do not prevent relevant details from getting buried or prevent hallucinations; choosing the contents still matters.

- **Different models and harnesses:** A reviewer can use a different model, including choices from Anthropic, OpenAI, or open-weight models. The harness—the software that organizes the agent’s work—can differ too. Reusing the same model and harness may reproduce similar biases, so both are candidates for variation.

Gannaway also proposes adversarial reviewers that inspect the same code and compare findings. He treats agreement as a stronger signal that a problem is real, while very different findings call for further investigation. The point of the comparison is to expose mistakes that one route through the review might miss. Agreement remains a review heuristic, not a guarantee that a finding is correct.

### Make a PR comment useful on future PRs

[8:19](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=499s)

Learning from a failure also has to outlast the review conversation. Postmortems can lead to changes in process or organization, which need their own follow-through. For code-level lessons, the practical question is how to turn knowledge held by a few people into a check that everyone can use.

The PR-comment example makes that conversion concrete. A comment on a pull request supplies the input; Qodo [suggests a rule](https://docs.qodo.ai/governance/rule-enforcement/rule-miner) based on it. The conversion gives the feedback an explicit form that future reviews can check.

![Recording frame at 9:00: Make a PR comment useful on future PRs](https://ai.engineer/api/talk-essay-media/c97813cd3bbf511be0de16ac3545c981f71b6e97119ac7d74d6d4f8d31981ab0)

Make a PR comment useful on future PRs — recording at 9:00

Applying the rule to later PRs reduces dependence on someone remembering to repeat the comment. Separately, the software graph can flag the rename’s large blast radius to a human or another agent, directing closer attention to a change that looked small in the diff. Running these checks through MCP or a CLI before opening the PR gives the coding agent an earlier chance to fix the problem.

### Check the implementation against the original intent

[10:15](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=615s)

An audience member describes already reviewing work with an agent and writing down the resulting guidance for the next run of the factory. The harder question is about intent: what happens when the context given to the implementation agent misses what the task was really meant to accomplish?

The distinction takes a moment to pin down. Gannaway first considers a poorly written ticket, then an agent that over-engineers a small request into a wholesale rewrite. The questioner sharpens the concern: the agent may be approaching the problem incorrectly and implementing the wrong thing. Review has to check the requested outcome as well as the implementation’s internal quality.

The live example addresses how a reviewer can check the intended outcome. Qodo supports integrations with Jira and Linear; a linked ticket supplies acceptance criteria to the PR review. The review then highlights [requirements gaps](https://www.qodo.ai/blog/how-qodo-uses-linked-specs-to-catch-missing-requirements/) against that ticket, making incomplete requested behavior part of the review output.

A requirements-gap finding tells the implementation agent to return to behavior the ticket requested. Its limit follows from its input: the check depends on the ticket expressing the real intent. An omitted or mistaken requirement still needs clarification; comparing the implementation with the written criteria cannot supply intent that those criteria never captured.

These checks can guide implementation before a PR exists. Gannaway recommends adding a skill that requests a review around the **25%, 50%, and 75%** points of the coding work. The specialized reviewer can then act almost like a manager, steering the implementation agent away from the wrong solution or unnecessary rebuilding. As implementation consumes more of the agent’s context window, a separate review can return attention to the requirements while the next edits can still change direction.

### Deciding when human review can be skipped

[13:53](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=833s)

The closing question is which changes can be merged without a human looking at them. Gannaway says some teams already do this and presents deciding when it is appropriate as the next step for the review layer.

Blast-radius information gives that decision a useful input: a one-line edit can affect several clients and warrant more scrutiny than its size suggests. The graph makes those consequences easier to inspect. The decision rule for when the available evidence is sufficient to allow an unattended merge remains open.

## Key takeaways

- Review the components connected across repositories. A one-line data-model rename can affect web, mobile, MCP, and CLI consumers even when local checks pass.
- Turn compatibility expectations into explicit rules, such as adding a deprecation flag or closer review for public API changes, and supply those rules to the coding agent before generation.
- A dedicated review agent can reserve context for codebase knowledge, the dependency graph, and information specific to the review. Varying models and harnesses aims to reduce shared blind spots.
- Qodo’s PR-comment example turns feedback into a suggested rule that can be applied to future PRs, while the software graph directs reviewer attention to changes with broad impact.
- Check implementation against the ticket’s acceptance criteria. Reviews around 25%, 50%, and 75% of the coding work are suggested checkpoints for catching the wrong direction while the implementation can still change.
- Blast radius can inform which changes need human scrutiny, while the criterion for allowing unattended merges remains an open decision in the talk.

## Resources

- [Qodo cross-repository review documentation](https://docs.qodo.ai/governance/cross-repo-code-review) — Companion documentation for following changes across repository dependencies and identifying affected consumers, the central concern in the Bitwarden example.
- [Qodo rule-mining documentation](https://docs.qodo.ai/governance/rule-enforcement/rule-miner) — A practical follow-up to the PR-comment example, covering the conversion of recurring review feedback and decisions into reusable rules.
- [How Qodo Uses Linked Specs to Catch Missing Requirements](https://www.qodo.ai/blog/how-qodo-uses-linked-specs-to-catch-missing-requirements/) — Companion reading for the ticket-checking demonstration, focused on connecting code review to requirements in linked specifications.

## Related talks

- [How to Build Quality Gates into Agentic Coding Workflows — Nnenna Ndukwe, Qodo AI](https://ai.engineer/talks/-AKPRSYccJc-build-quality-gates-into-agentic-coding-workflows) — Continues from this architecture overview into a FastAPI payments workflow, with repository rules, deterministic checks, Qodo review findings, and a demonstrated remediation pass.
- [Stop Prompting — Greg Pstrucha, Sentry](https://ai.engineer/talks/E3KbFLAGD6A-stop-prompting-greg-pstrucha-sentry) — Develops the PR-comment-to-rule idea through repository policies and custom linters that preserve recurring feedback across agent sessions.
- [How to Know When an AI Agent Can Work Unsupervised — Evan Kormos, Coinbase](https://ai.engineer/talks/_4Ph2dhmUFI-know-when-ai-agent-work-unsupervised-evan) — Takes up the closing autonomy question through bounded tasks, repeated evaluations, traceability, human fallback, and a staged path from full review to exception handling.

## Slides

### Maintaining quality and trust as output scales

Qodo’s Cole Gannaway introduces the challenge of preserving quality and trust as software output grows, framing the discussion around the evolution of software factories at AI-first companies.

[0:16](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=16s) [Qodo title slide reading Maintaining quality and trust as output scales, crediting Cole Gannaway as Strategic Solutions Engineer at Qodo. A white-and-purple detective mascot appears on the right, with conference branding and a speaker inset surrounding the slide.](https://assets.ai.engineer/sites/aiecode2025/sha256/95a3e381027560f37016f315ad10672d64e242431e0bbc9aaefaf280f1aa1b6c.webp)

Maintaining quality and trust
as output scales

AI IN PRODUCTION

Cole Gannaway
STRATEGIC SOLUTIONS ENGINEER · QODO

qodo
AI ENGINEERING · NYC

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

### Agents write faster, so review becomes the queue

Agents open more and larger pull requests, which pile up at human review. The workflow puts Qodo’s first pass before human approval, so reviewers start from flagged findings instead of a raw diff.

[0:54](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=54s) [Workflow diagram connecting Ticket, Coding agent, Pull request, Human Review, and Merge. Human Review is outlined in pink and labeled Bottleneck. A purple Review in Qodo first-pass box branches from Pull request and feeds into Human Review. Two lower callouts explain the review queue and review's role in quality and trust.](https://assets.ai.engineer/sites/aiecode2025/sha256/2f00c5cf71ca1d44d40c2ec0c1671804b994bc29ef3bacf4da07906fb446c2fc.webp)

THE SOFTWARE FACTORY
Agents write faster, so review becomes the queue

Ticket
the backlog

Coding agent
writes the diff

Pull request
opened

BOTTLENECK
Human Review
approves

Merge
and ship

Review in Qodo
first pass

• The bottleneck
Agents open more PRs, and bigger ones. Every PR still waits for a reviewer, so work piles up at review.

• The critical station
Review is where quality and trust are decided. Humans start from flagged findings instead of a raw diff.

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
qodo
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room

### One-line rename

An illustrative Bitwarden diff renames the public RevisionDate property to LastModified. The AI reports updated server references and passing tests; Gannaway says he would probably merge it.

[2:03](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=123s) [Slide titled One-line rename with an illustrative C# diff changing a public DateTime property from RevisionDate to LastModified. A displayed AI message says the rename aligns with newer endpoints, server references were updated, and all tests pass.](https://assets.ai.engineer/sites/aiecode2025/sha256/c8fbca7d4fa8261c732bce43570dc56eb4fbf372cd6f9c0c3afdd51c5f6d4a0a.webp)

THE FAILURE · 01
One-line rename

bitwarden/server  src/Api/Vault/Models/Response/CipherResponseModel.cs
ILLUSTRATIVE

14    public class CipherResponseModel
15    {
16  - public DateTime RevisionDate { get; set; }
16  + public DateTime LastModified { get; set; }
17    }

AI
Renamed RevisionDate → LastModified for consistency with newer endpoints. Updated all server references. All tests pass.

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
qodo
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room

### Would you merge this?

The illustrative RevisionDate → LastModified PR looks ready to merge: build, unit tests and lint all pass, and a reviewer approves. Gannaway asks whether green checks are enough when reviewers haven't read every changed line.

[2:38](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=158s) [Slide showing an illustrative pull request to rename RevisionDate to LastModified. Build, unit tests and lint have green check marks. An approved review and a Merge pull request button appear below.](https://assets.ai.engineer/sites/aiecode2025/sha256/b887ebfe363f2f03ce1726f112789b6567ce21e20e0568e276200a349f74bf96.webp)

THE FAILURE · 02
Would you merge this?

Rename RevisionDate to LastModified #4821
ILLUSTRATIVE
agent wants to merge 1 commit into main from rename-revision-date

✓ build    Successful in 4m
✓ unit tests    All passed
✓ lint    No issues

✓ APPROVED    1 approving review · no changes requested
MERGE PULL REQUEST

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

### Seven clients the agent never opened

In this illustrative Bitwarden example, a one-line server change can affect seven clients that read revisionDate. Android and iOS are boxed together to highlight that they can't be hot-fixed.

[3:37](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=217s) [Illustrative dependency diagram centered on bitwarden/server, connecting the web vault, browser extension, desktop app, CLI, MCP server, Android and iOS through paths labeled reads revisionDate. Android and iOS are boxed together beside a note saying they cannot be hot-fixed.](https://assets.ai.engineer/sites/aiecode2025/sha256/deb0ca01c07e726e9cdb797c307b7029ad455a828278cd1cfce4637570982353.webp)

THE FAILURE · 03
Seven clients the agent never opened

bitwarden/server

Web vault
reads revisionDate

Browser extension
reads revisionDate

Desktop app
reads revisionDate

CLI
reads revisionDate

MCP server
reads revisionDate

Android
reads revisionDate

iOS
reads revisionDate

← can't hot-fix

ILLUSTRATIVE

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

### Context is king

The illustrative Bitwarden graph highlights downstream readers of revisionDate. Client/server file mappings trace sync, authentication and push notifications so a review agent can assess a change across repositories.

[4:13](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=253s) [Illustrative repository graph linking clients to a central server and highlighting downstream MCP, Android and iOS repositories. An integration-surface panel maps client and server components for synchronization, authentication and push notifications, including clients reading revisionDate on every sync.](https://assets.ai.engineer/sites/aiecode2025/sha256/303128fa64d50560d3df3194dc99ef61371e080f0ef2d7a6db194e4798a7705e.webp)

Context is king
STATION 01 · CONTEXT

Repositories
Relationships

Repos
Hub
Connected

bitwarden-clients
bitwarden-server
bitwarden-ios
bitwarden-mcp-server
bitwarden-android
↑ downstream repos that read the field

bitwarden-clients → bitwarden-server
ILLUSTRATIVE
SERVICE
Clients consume Server API, Identity and Notifications.

INTEGRATION SURFACE
▸ libs/common/src/vault/models/response/cipher.response.ts ↔ src/Api/Vault/Models/Response/CipherResponseModel.cs — clients read revisionDate on every sync.
▸ libs/common/src/services/api.service.ts ↔ src/Identity/* — OAuth tokens via POST /connect/token.
▸ signalr-connection.service.ts ↔ src/Notifications/* — SignalR hubs for push sync.

Interface text:
CONTEXT
STANDARDS
PRE–PR REVIEW
PR GATE
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

### Shared standards, enforced

Qodo’s illustrative list highlights a rule learned from PR history: keep public API changes additive and deprecate before renaming or removal. Gannaway proposes turning human review lessons into reusable rules.

[4:55](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=295s) [Slide listing five illustrative coding rules. The highlighted third rule calls for additive public API fields and deprecation before renaming or removal. A badge reads Learned from PR history, and the Standards stage is highlighted in the navigation.](https://assets.ai.engineer/sites/aiecode2025/sha256/a65dcb3152e813a76ba9b6068e8d6e9fc0003310a542697a12f6b969ee03c34d.webp)

Shared standards, enforced
STATION 02 · STANDARDS

Rules in Qodo bitwarden/server
ILLUSTRATIVE

01 Use async controllers for I/O
02 No secrets in logs
03 Public API fields are additive. Deprecate before you rename or remove.
LEARNED FROM PR HISTORY
04 Validate input at the controller boundary
05 Feature flags for every schema change

Interface text:
CONTEXT
STANDARDS
PRE-PR REVIEW
PR GATE
AI Engineer
NEW YORK
PRESENTED BY
arize
qodo
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room

### Standards and context go in first

In this illustrative workflow, the coding agent loads 12 rules and finds 7 downstream consumers before editing. It plans to keep RevisionDate and add LastModified, turning the requested rename into an additive change.

[5:46](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=346s) [An illustrative coding-agent panel shows a request to rename RevisionDate to LastModified. A purple outline highlights 12 loaded rules and seven downstream consumers found. Dimmed lines below describe keeping the existing field and adding the replacement.](https://assets.ai.engineer/sites/aiecode2025/sha256/7f69b4654e10ac8e56b29f3fa6b46328bf1cba702867a5b6865cacc7cdef0166.webp)

Standards and context go in first

STATION 03 · PRE-PR REVIEW

coding agent – bitwarden/server
ILLUSTRATIVE

> agent: rename RevisionDate → LastModified

calling qodo get-rules ............ 12 rules loaded
calling qodo codebase-wisdom ...... 7 downstream consumers found

planning additive change · keep RevisionDate, add LastModified
editing CipherResponseModel.cs

Interface text:
CONTEXT
STANDARDS
PRE-PR REVIEW
PR GATE
AI Engineer
NEW YORK
PRESENTED BY
arize
qodo
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room

### Two agents, two kinds of context

Exploration, implementation and debugging can bury the implementation agent’s standards. A separate Qodo review agent gets the diff and full standards, with room to focus. The write, review, fix loop runs before the PR opens.

[6:28](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=388s) [Two context diagrams compare an implementation agent's small initial standards segment followed by exploration, implementation and debugging with a Qodo review agent's diff, full standards and room to focus. A caption describes a write, review and fix loop before the PR opens.](https://assets.ai.engineer/sites/aiecode2025/sha256/a0bcbcabc068e9482d90ec50148cd919bb1e50442fd8bce31df56696871b37e7.webp)

Two agents, two kinds of context

STATION 03 · PRE-PR REVIEW

Implementation agent
MAKE IT WORK
Exploration
Implementation
Debugging
Your standards: a sliver at the start, buried by everything after

Qodo review agent
MAKE IT GOOD
The diff
Your full standards
Room to focus

Write, review, fix: the loop runs before the PR opens, so it arrives review-ready.

Framing adapted from Matt Pocock, “Fixing the PR Bottleneck,” AI Engineer Paris. It echoes TDD’s red, green, refactor (Kent Beck).

Interface text:
CONTEXT
STANDARDS
PRE-PR REVIEW
PR GATE
AI Engineer
NEW YORK
PRESENTED BY
arize
Engineering the future of AI

### The agent that wrote the code doesn't grade it

An illustrative pre-PR review shows a separate agent catching an API rename that would break four downstream repos. It recommends keeping RevisionDate, adding LastModified alongside it and deprecating the old field.

[7:28](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=448s) [An illustrative pre-PR review flags a high-severity API contract break after RevisionDate is renamed to LastModified while downstream repositories still use the old field. A purple suggested-fix box recommends keeping RevisionDate, adding LastModified alongside it and deprecating the old field.](https://assets.ai.engineer/sites/aiecode2025/sha256/074a336186e87cf8c51162bb6f722f102127f3ceb13c8e92a99e7df9192de92f.webp)

The agent that wrote the code doesn't grade it

STATION 03 · PRE-PR REVIEW
CONTEXT
STANDARDS
PRE-PR REVIEW
PR GATE

REVIEW IN QODO · PRE-PR
ILLUSTRATIVE

Breaking API contract
HIGH

RevisionDate was renamed to LastModified in CipherResponseModel. 4 downstream repos still read revisionDate: clients (web, browser, desktop, CLI), android, ios, mcp-server.

Violates rule: Public API fields are additive.

SUGGESTED FIX
Keep RevisionDate, add LastModified alongside it, mark the old field deprecated.

Interface text:
AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

### Channel bookmark folders: requirements and acceptance criteria

Cole opens a Jira ticket to show how Qodo checks a PR against its acceptance criteria. Folder ordering must stay stable, deleting a folder must preserve its bookmarks, and folder actions must use existing bookmark permissions.

[12:29](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=749s) [A Jira ticket lists requirements for channel bookmark folders, including ordering, grouping, safe deletion, remembered collapse state, limits and permissions. Below are acceptance criteria, out-of-scope items and a note to reuse existing bookmark permissions.](https://assets.ai.engineer/sites/aiecode2025/sha256/65b810eaa7c32dc1f034e2dbff3290843783c8e30bdbb9b78f37ebfcc43154bc.webp)

Functional requirements

1. A channel can have folders. A folder has a display name and can be ordered relative to other folders.
2. A bookmark can be filed into a folder or left ungrouped.
3. Listing a channel's bookmarks returns them grouped by folder, with the folder order and the order of bookmarks within each folder preserved.
4. Deleting a folder is safe: the channel is never left in an inconsistent state, and bookmarks that were in the deleted folder are still reachable afterwards (e.g. moved back to ungrouped) rather than lost.
5. Each user's collapsed/expanded state per folder is remembered across sessions, so collapsing a folder on one visit keeps it collapsed on the next.
6. A channel may contain at most a reasonable maximum number of folders; attempts to exceed the limit are rejected, mirroring the existing per-channel bookmark cap.
7. Folder management actions (create, rename, reorder, move bookmark into a folder, delete) are gated by the same bookmark permissions already used for the channel type (public/private add/edit/order/delete bookmark permissions), so only users who can manage bookmarks can manage folders.

Acceptance criteria

☐ Creating a folder and filing bookmarks into it returns them grouped on the next list call.
☐ Folder order and within-folder order are stable across list calls.
☐ Deleting a folder leaves the channel consistent and its bookmarks reachable.
☐ A user's collapsed folders stay collapsed after re-opening the channel.
☐ Exceeding the folder limit returns a 400.
☐ A user lacking bookmark-management permission cannot create/move/reorder/delete folders.

Out of scope

• Nested folders (folders within folders).
• Drag-and-drop UI (client tickets).
• Sharing folder layouts across channels.

Notes

Reuse the existing channel-bookmark permission scheme rather than introducing new permissions.

OCTOBER 13, 2026
EXPO SESSION
McCarthy Room

Interface text:
AI in production governance
Qodo
AI Code Review – Qodo: Dep[illegible]
Cole-Qodo-Demo-2026 - Go[illegible]
Cole-Demo-Findings by cole[illegible]
Cole-Demo-Cross-Repo-Con[illegible]
[SCRUM-562] Channel book[illegible]
qodo-confluence.atlassian.net/browse/SCRUM-562
Okta
Internal-Links
Local
Demo
POVs
Jira
Search
+ Create
Ask Rovo
Spaces / Qodo / Add epic / SCRUM-562

For you
Recent
Starred
Apps
Spaces
Recent
Qodo
More spaces
Recommended
Collect requests
Try
Filters
Dashboards
Confluence
Assets
Teams
Goals
Projects
Customize sidebar

Unlock your AI teammate
Rovo connects your tools and knowledge so work gets done for you.
Try Rovo now

1
In Progress
Agents
</>
Improve Story
Details
Assignee
Unassigned
Assign to me
Labels
Add labels
Parent
Add parent
Team
Add team
Sprint
SCRUM Sprint 1
Story point estimate
0
Fix versions
None
Reporter
Jonathan Klick
Development
Automation
Rule executions
Created 4 months ago
Updated 4 months ago

### Qodo review findings for channel bookmark folders

Gannaway returns to Qodo’s GitHub review to check the linked ticket’s requirements. It flags missing permission checks for moving bookmarks into folders alongside bugs and cross-repo conflicts; two other findings are dismissed.

[12:42](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=762s) [A GitHub pull request displays Qodo's categorized review summary for channel bookmark folders. The critical findings list includes bug, requirement-gap, skill-insight and cross-repository-conflict labels. Two entries are crossed out and marked dismissed.](https://assets.ai.engineer/sites/aiecode2025/sha256/05af0655dd752045df928f08b8d835a0961c7618cf6f18984f03c69735a0422f.webp)

MM-62210: add channel bookmark folders #5
Closed
gadianton wants to merge 1 commit into master from feature/channel-bookmark-folders

Code Review by Qodo
Bugs (10)
Rule violations (0)
Requirement gaps (2)
Cross-repo conflicts (3)
Team insights (0)
Skill insights (2)
Security issues (0)

Critical
1. Editors unfile bookmarks by renaming | Bug | Correctness | New
2. Users make folders contain themselves | Bug | Correctness | New
3. Mobile users cannot open folders | Cross-repo conflict | Correctness | New
4. Deleting a folder loses its bookmarks | Bug | Reliability | Shift left
5. Members alter other channels’ bookmarks | Bug | Security | Shift left
6. A channel member can alter any bookmark | Skill insight | Security | Shift left
7. moveChannelBookmarkToFolder lacks permission checks | Requirement gap | Security
8. WS updated payload mismatch | Dismissed | Cross-repo conflict | Correctness
9. Grouped listing drops updates | Bug | Correctness
10. Missing folder enum migration | Bug | Reliability
11. Bookmarks list response changed | Cross-repo conflict | Correctness
12. DeleteBookmarkFolder deletes folder bookmarks | Dismissed | Requirement gap | Correctness

View warning (6)

qodo-ai Bot reviewed on Jun 23
server/channels/app/channel_bookmark.go
server/channels/api4/channel_bookmark.go

AI Engineer
NEW YORK
PRESENTED BY
arize
OCTOBER 13, 2026
EXPO SESSION
McCarthy Room
qodo

Interface text:
github.com/qodo-se/mattermost-core/pull/5
AI in production governance
Qodo
AI Code Review – Qodo: Dep[illegible]
Cole-Qodo-Demo-2026 - Go[illegible]
Cole-Demo-Findings by cole[illegible]
Cole-Demo-Cross-Repo-Co[illegible]
MM-62210: add channel boo[illegible]
Okta
Internal-Links
Local
Demo
POVs
Archive pull request
View reviewed changes
Show resolved

## Full transcript

[0:12](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=12s) Well, thanks so much for showing up to, uh, this discussion here. Um, I'm-- I'll probably actually ask for a little audience participation as well. Um, would love to get to know how you guys are thinking about things. The goal of today, um, is to talk a little bit about Qodo, which is the organization I'm representing, as well as how software factories have evolved. Uh, this is sort of what we're seeing in the industry, where a lot of AI native or AI first companies are starting to head. I think everyone has a grand vision of where these

[0:42](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=42s) factories can go, and we believe Qodo is a critical part of that, not the complete picture of that. So there's an element of what we do, where we specialize, and then areas that are outside, and we'll make sure to be clear on some of that. Um, I'll, I'll kinda hop into the first one that's worth kinda walking through. Um, I'm, I'm what's called a solutions engineer, so I spend time with organizations talking through, uh, how our product or other products might fit into their workflows and teaching about Qodo as a platform. What I often hear from

[1:12](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=72s) customers is that they're super excited about going from ticket all the way to production. From somebody generating code or somebody coming up with a ticket and being able to push that all the way through, and what they're finding is at the pull request level or at the review stage, they're struggling. This has become a huge bottleneck. Code generation, I wouldn't say is solved, but it's definitely moving at a rate that we've never seen before. And so, uh, this has been a big bottleneck. This is also

[1:42](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=102s) where, uh, it's critical that we provide the human or the coding agent or the review agent with as much context as we can to make sure that we're making the right decisions. This is really the trust and verification layer. Um, all the other components are still valuable, but just worth noting, that's where we'll focus a lot today is on that review section here.

[2:04](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=124s) I wanna give a, a practical example. Um, as I mentioned, code generation is not necessarily solved, but when we're looking at code and when we're creating features and when we're trying to generate new code, new features, we can often miss things that we're not trying to. So this is an example where we have just a one-line change. This is on Bitwarden, which is a open source password manager. And you'll notice that we have just one line change to our data model. If I was a developer and I saw

[2:34](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=154s) this, it seems good to me, right? I'm gonna say this seems like the right change. I wanted to rename it. I would probably merge it. I would probably look and see that the build passed, that unit test passed, maybe even my linters passed. It seems like this is a change that we needed. This is a feature that we wanted. Let's, let's approve it. So I'm curious, maybe just from like a show of hands, but like how are you guys when you're talking about code review or review changes? I would imagine you have a bunch

[3:04](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=184s) of tools. When they all give you green checks, does that mean it's good to go or what does that, what does that look like for you guys? Maybe a show of hands, like how many have merged a PR that they were like, "Uh, seems good to me. Not a hundred percent sure. I didn't look at all the lines of code." Um, maybe just a raise of hands. Yeah. Right. So every-everyone here, I think just about everyone here is like, we can't look at all the lines of codes that have changed, so we rely on these tools. There's a bunch of great tools out there. Worth noting, not all tools are built the same and not all, uh,

[3:34](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=214s) context is built the same. In this example that we would've just merged, we would've missed the blast radius or the effect that this can happen. This one line of code change can affect multiple repos. In this example, again, I'm using Bitwarden as, as a sort of an illustrative example. We have a back-end server that could be connected to web clients, that could be connected to mobile or iOS devices. It could be connected to MCP servers or CLI. And you'll notice that all of these components are affected on that one line of change. So

[4:04](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=244s) this is typically found in production, right? Uh, maybe a bug or a user story or the web app crashes. And so we'd love to be able to catch this as early as possible. Context is king here. Um, one of the things that, uh, Qodo will do, and I think, uh, is, is really important, is build out a software graph of the repositories that your team is working on today. This will build it out automatically, and it'll also build out an integration surface. So not just, uh, you'd be disappointed or,

[4:34](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=274s) uh, it wouldn't be as valuable if we said just Bitwarden server was connected to Bitwarden Android, but not what the actual components are that are connected. And so this is a huge area of if we're building this software factory, if we're not looking at every line of code, how do we get this to my agent, to my review agent, uh, to be able to take this into account?

[4:56](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=296s) Another thing that's worth, uh, calling out is like, not everything is, uh, is, is purely functional. Some are gonna be a bit more senior level reviewers, custom rules, maybe a bit of taste that's involved, and how are we learning from some of our past mistakes? Um, so when we go back to like the software, uh, factory, for example, here, we have a human that reviews it, but is there a way that we can bring that human reviewer back into the code intelligence, back

[5:26](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=326s) into the review layer, rather than it just being every time that's the bottleneck, if that makes sense.

[5:33](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=333s) So in this example here, we have a custom rule that we can add which says, "Hey, if we're gonna change anything about public APIs, we wanna make sure that we add either a deprecation flag or we review this a bit more."

[5:47](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=347s) Additionally, we'd love to have this information pre-PR, pre-code generation. So is there an opportunity for us to bring this information in before we've ever generated a line of code, knowing that we have potential downstream effects if we make some of these changes? These are some of the areas you can see that, uh, in this example, we've got an MCP server, we've got Codebase Wisdom, we're getting those custom rules or, or tribal knowledge that might exist, bring all that into, uh, into our coding agent long before we're pushing it up.

[6:17](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=377s) That doesn't guarantee that it's not gonna make mistakes, right? I think any-anybody would say that we, we wanna double-check, but this gives us a much better opportunity and a much better, uh, shot at making it right on the first try. Worth calling out here, uh, I think m-many organizations are thinking, "Should I just use Claude Code or my implementation agent to just do the review?" Uh, this review stage has some information, but some of this is actually valuable in the actual generation stage. It's also worth noting that an implementation agent

[6:47](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=407s) has a bunch of other things that it's doing that are not related to review. And context windows are getting bigger, but that doesn't mean that things don't get buried, that doesn't mean things don't get hallucinated. And so there's debugging, there's implementation, there's exploring the code base, versus a review agent has a specific set of context that we wanna use. And you'll notice, uh, here on the right, we potentially have some room to focus on other things as well. So not just the Codebase Wisdom that we saw or the graph, we

[7:17](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=437s) can even bring in more information that might be custom to this specific run or this specific review, um, that we have potentially some room for as well.

[7:30](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=450s) So this kinda goes into the agent that wrote the code. We don't need him, uh, grading the code. O-one, we have more context window available. The other is, uh, we wanna make sure that these are independent, so that can be things like, uh, the LLM that's being used under the hood, whether it's Anthropic, whether it's OpenAI, whether it's open-weight models. Can we leverage multiple models to try to get rid of some of that bias? Another is the harness. If the harnesses are the same, we could have some bias there. We would love to be able to swap out

[8:00](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=480s) all of these or even make adversarial reviewers, um, that have the ability to look at the same code and see if there's differences in what we're finding. If we find the same thing, probably a high signal that that's, that's true. If we find completely different things, that might be worth further investigation.

[8:19](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=499s) Awesome. And then lastly, how do we take this information from this specific example and make sure that it doesn't happen again? Uh, I know a lot of organizations that I work with will do postmortem reviews, and th-these are valuable. They'll-- We learn from it. Often we learn things that don't, don't have anything to do with code, but have to do with organizational changes or process changes that we need to do. But for the code level changes, how do we bring that back in and make that actual tribal knowledge a organizational knowledge that everyone can

[8:49](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=529s) use, goes in automated fashion, and this is a, this is a huge area as well. You can see in this example here, uh, Qodo, for example, suggesting a rule based on a comment on a PR, so that way we can go back and now apply that rule to every PR in the future. Uh, you also see that because we have that software graph information, we can see the blast radius of that one line of code change was large. We can flag that to the reviewer, whether that's a human or another agent, to make sure that we're looking at this a bit

[9:19](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=559s) closer.

[9:22](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=562s) So wanted to show this at least from a, a, a, you know, high level view of what we're talking through. There's a bunch of things involved in each software factory. Context is gonna be king, so can we get the right data, the right information? Can we apply those rules or standards that we may already have or ones that we wanna learn from? And then can we check this pre-PR, uh, using MCP, CLI? Like, there's great things that catch at the PR level. However, if we could have caught it earlier, then maybe we could have caught it at the code gen

[9:51](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=591s) stage or have ability to remediate and go from there. Um, I'll show a little bit of this live, but I just wanted to at least show some of what we're thinking, how we've seen customers building out their software factories. Um, curious if there's any questions so far. I'm, I'm happy to pause, but, um, what, what does this look like for you guys?

[10:15](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=615s) Were you, were you raising your hand?

[10:16](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=616s) Yeah.

[10:16](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=616s) Yeah, go for it.

[10:16](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=616s) So, uh,

[10:21](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=621s) during the PR stage-

[10:22](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=622s) Yeah.

[10:23](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=623s) Uh, we go through a review, or I go through a review with the agent, and I tell the agent, "Hey, I wanna change XYZ. I wanna load some questions about the code base for this implementation." Um, and then I go in and I fill in some documentation, basically what you're saying, where it will get applied on the next run of the factory.

[10:48](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=648s) Yes.

[10:49](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=649s) Uh, so you're doing all that then, right?

[10:52](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=652s) Yep. Yeah. We're able to, to bring in... So I'm, I'm showing just some, some examples of what we do, and I'm kinda focusing on the software graph and the custom rules. Uh, we can bring in a bunch of other things like ticketing systems, things like that as well.

[11:04](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=664s) Do you find that most of your clients have problems with intent on before the code gets even written?

[11:12](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=672s) Yeah. So if we go back to this section here on the, uh, the ticket right here, right? Maybe the ticket isn't written super well. Is that, is that kinda what you're describing?

[11:22](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=682s) Maybe, or-

[11:22](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=682s) Okay.

[11:23](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=683s) Whatever context is produced to generate the implementation aspect, um, the linkage between those two, it's missing the real intent-

[11:36](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=696s) Mm.

[11:36](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=696s) And so it's implementing the wrong, the wrong thing.

[11:40](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=700s) Guiding it. Guiding it. So you're saying like, uh, the agent can then start going, like, I think one that, that maybe a lot of people have experienced is the over-engineering of some of these agents, where I asked it to do one thing, and it's now, like, recreating everything from scratch. Uh, is that kinda what you're describing there? And maybe even...

[11:58](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=718s) Or approaching the problem incorrectly. More, more like-

[12:01](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=721s) Just could be-

[12:01](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=721s) Approaching the problem incorrectly

[12:03](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=723s) Totally incorrect. So not even, uh, over-engineering, just, just, just wrong. Yeah. Um, so Qodo, I can maybe even show a little bit of this live here. If I go in... We've got integrations with things like Jira tickets or, uh, Linear tickets, and then these will go into every PR, uh, review. So if I go to, like, this one, for example, you can see here, um, we'll link in tickets directly into it. Wow. When you go, when you go from dark mode to light mode, uh, you really get, you get

[12:33](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=753s) blasted there. Um, you can see there's acceptance criteria in here. And then if I go back to the review, so if I go back here, you'll see that we actually will highlight requirements gaps based on that ticket that we just saw. Um, so this is when we're, when we're talking Qodo, we're not looking at just those things, but, uh, we're looking at are we completing the ticket? So are we actually going down that, that rabbit hole? And because we can do this review PR, uh, pre-PR, we can actually guide the agent. So typically, what we'll do when we work with clients

[13:03](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=783s) is we'll say, uh, run a review periodically. So, uh, we'll, we'll often put a skill in there which says, as we're generating code about at your twenty-five percent, your fifty percent, your seventy-five percent mark, go ahead and run a review, make sure we're on the right path. As I mentioned, that context window earlier starts to shrink, and so, like, this is one of those things where a, uh, if I go to this one, this specialized review agent can act as almost a manager agent in this way of guiding the agent, um, from doing the wrong

[13:33](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=813s) thing or over-engineering it or things like that. Did that help answer that question there?

[13:40](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=820s) And it may be, may be further that we need to talk through it. Okay. Cool. Any other questions, comments? Just curious here.

[13:53](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=833s) Okay. Awesome. Uh, we'll be at the booth, um, downstairs, uh, the, the Qodo booth. I'm happy to talk through it with you guys further. I think a lot of our, our clients are getting towards this, how do we make this software factory run? And the critical section that at least our platform is solving for is that review stage. How do we give the human as much information? How do we bring this context layer, uh, this code intelligence and wisdom layer into the review agent to make it,

[14:23](https://www.youtube.com/watch?v=YqxpPI7YUjE&t=863s) uh, as accurate, as trustworthy? And so then, um, I'd say the, the next layer of where we're going is what ones can be merged without a human looking at it. I think today people are already doing that. We'd love to know which ones that we should, which ones that we should not. Um, and so that, that blast radius, uh, information is available there.
