GitLab Self-Managed Runs Two AI Code Reviewers Depending on User Seat Type

·6 views

GitLab Self-Managed offers two distinct AI code review features under the same @GitLabDuo handle: the agentic Code Review Flow and the non-agentic GitLab Duo Code Review. Which feature runs is determined by whether the user who triggers the review holds a GitLab Duo Enterprise seat — if they do, the non-agentic single-pass review activates; if not, the more capable agentic flow runs instead. Code Review Flow can analyze repository structure and cross-file dependencies through multi-step reasoning, while GitLab Duo Code Review is limited to the merge request's file diffs in a single pass. This distinction is critical for teams enforcing standards that span multiple files, as the Enterprise-seat-triggered reviewer cannot read beyond the immediate diff. Group Owners can override the default behavior to pin all reviews to Code Review Flow regardless of seat type, with credit usage attributed to the initiating user.

Read the full story at DEV Community

This is an AI-generated summary. ShortSingh links to the original source for the complete article.

Discussion (0)

How Java and Go Guarantee Atomicity, Visibility, and Ordering in Concurrent Code

A technical deep-dive on DEV Community examines how programming languages enforce safe concurrent operations through atomic APIs. In Java, AtomicInteger methods like incrementAndGet() perform read-modify-write as a single indivisible operation, preventing lost updates when multiple threads modify shared state. The volatile semantics underlying Java's VarHandle establish synchronizes-with relationships, ensuring that writes made before an atomic update are visible to threads that observe that update. Go's sync/atomic package offers similar guarantees, where observing one goroutine's atomic operation implies a synchronized-before relationship with the observing operation. The article uses annotated code examples to illustrate how atomicity, visibility, and ordering work together under each language's memory model, with CPython noted as lacking a symmetric application-level atomic API.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

How Race Conditions Break Stock Updates and Three Ways to Fix Them

Concurrent stock update requests can cause race conditions where multiple operations read the same inventory value simultaneously, pass availability checks, and each record a successful decrement — even when only one unit exists. This flaw means the final stock count may appear correct while the number of successful transactions exceeds actual available inventory. An atomic SQL update, such as decrementing stock directly within a conditional WHERE clause, eliminates the application-level read-check-write gap that creates the vulnerability. PostgreSQL row locking with SELECT FOR UPDATE offers another approach, serializing concurrent transactions so only one can read and modify a row at a time. Testing these scenarios requires validating not just the final stock value but also that the count of successful operations never exceeds initial inventory.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Why Disposing a Lifetime Should Release a Hold, Not Kill the Shared Worker

In mobile applications, multiple activations often share a single background worker, making naive disposal of IDisposable lifetimes dangerous. If disposing a lifetime unconditionally stops the shared worker, one activation can silently tear down resources still needed by another. The safer design treats a lifetime as a hold on shared work, where the worker only stops when the last hold is released. This requires atomic synchronization for both start and stop transitions, and each hold must be bound to the specific run it joined to prevent stale releases from affecting restarted workers. Defensive cleanup code across multiple branches deserves the same scrutiny, as any branch performing terminal teardown can shut down a resource still in active use.

0 comments Read more at DEV Community

ProgrammingDEV Community ·

Why AI Agents Lack Persistent Memory and How Dedicated Memory Systems Help

AI agents typically lose all context between sessions, forcing users to repeatedly re-explain preferences, decisions, and project details each time a new conversation begins. Unlike a large context window, which only holds information active within a single interaction, persistent memory stores selected information externally and retrieves it when relevant in future sessions. Developers working with agent frameworks have noted that the core challenge is not the model's ability to answer questions but its inability to maintain continuity across interactions. Effective memory systems must be selective, storing only high-value information such as user preferences, technical decisions, and recurring patterns rather than entire conversation histories. The emerging approach treats agent memory as a separate read-write system, distinct from the prompt itself, designed to bridge the gap between isolated sessions.

0 comments Read more at DEV Community