FlowDeck

Optimize token usage and context window discipline. Reduce costs and improve response quality through smart context management.

Unified context lifecycle for FlowDeck sessions — ingest, filter, prune, protect, summarize, and persist with telemetry.

Predict affected files, modules, APIs, tests, and DB paths before changes. Returns an impact map for human review.

Map architecture, conventions, and file structure into `.codebase/`. Use when onboarding or before deep feature work.

Plan differently when the agent has low certainty — ask for clarification or narrow scope instead of pretending full understanding.

Protect critical context from pruning during compaction. Preserve active plans, safety files, pending operations, and user intent anchors.

Load full project context at session start. Read STATE.md, PLAN.md, PROJECT.md, CONVENTIONS.md, and ARCHITECTURE.md to brief any agent on where work stands.

Build and maintain a persistent graph of architecture, conventions, bug history, ownership patterns, and module relationships for this specific codebase.

Maintain continuity across FlowDeck sessions by loading previous context, checkpointing mid-session state, and writing structured summaries at session end.

Review code for security vulnerabilities, logic errors, and quality issues. Returns findings ranked by severity with remediation steps.

Explore and document an unfamiliar codebase. Use when joining a new project or generating project documentation.

Django patterns — models, ORM, class-based views, middleware, URL routing, forms, project layout. Activate when writing or reviewing Django code.

Route risky patches to the right reviewer — security, backend, infra, or domain owner — by change type.

Modern Java 17+ patterns — records, sealed classes, Stream API, CompletableFuture, Spring Boot, JPA. Activate when writing or reviewing Java.

Break complex features into a phased plan with parallel tasks, dependency graph, and verifiable success criteria. Use before multi-file work.

Python idioms — type hints, dataclasses, async/await, generators, pytest, common pitfalls. Activate when writing or reviewing Python code.

Refactor safely — keep tests green, change structure without behavior change, no public API breakage. Use for code maintenance.

Strict research hierarchy before writing code — search codebase, docs, web, and registries in order.

Rust patterns covering ownership, lifetimes, error handling, traits, async with Tokio, and smart pointers. Activate when writing or reviewing Rust.

Enforce test-first development and measure coverage gaps. Drives write-test → implement → verify. Use for new features and bug fixes.

Lightweight append-only telemetry layer for tracking session health, agent performance, and decision quality across FlowDeck operations.

Record why the agent changed something, what evidence was used, and what assumptions were made — so code reviews become much faster.

Build autonomous agent pipelines — construct agent loops, wire multi-agent orchestration, implement self-healing retry logic, and measure agent effectiveness

Assign a confidence and risk rating to every AI-generated change. Returns safe, review-required, or high-risk verdict with specific signals.

Show the likely downstream consequences of a proposed change — hidden dependencies, fragile integration points, and predicted breakage categories.

Estimate the most likely regression categories for a proposed change — performance, auth, schema, UI states, async flows — before merging.

Identify which areas of a proposed change are weakly covered by tests and suggest the minimum high-value tests to add first.

Create consistent releases and changelogs from merged PRs. Proposes semantic version bump, drafts release notes, and provides a copy-pasteable release command.

Define app shell structure, navigation model, and reusable surface patterns for web/mobile apps

Review responsive behavior and breakpoint fidelity against design intent

Backend architecture patterns for services, APIs, data access, and middleware design.

Apply Clean Architecture boundaries to keep domain logic isolated from frameworks and infrastructure.

Command Query Responsibility Segregation patterns for separating write and read models.

Domain-Driven Design patterns for bounded contexts, aggregates, and ubiquitous language.

Event-driven architecture patterns for asynchronous workflows and decoupled services.

Ports-and-adapters architecture patterns for testable, framework-independent domain logic.

Layered architecture patterns for separating presentation, application, domain, and data layers.

PostgreSQL schema, query, indexing, and performance patterns.

Saga coordination patterns for distributed transactions with compensating actions.

REST API design patterns for resource naming, status codes, pagination, filtering, versioning, and error responses. Activate when designing or reviewing API endpoints.