biotrackr

Blazor component architecture, Razor component patterns, Radzen UI library, and Blazor-specific UX patterns. Use when: building Blazor components, structuring Razor component hierarchy, using Radzen components, implementing Blazor forms, managing component state, Blazor rendering modes, Blazor layout design.

Ensure .NET/C# code meets best practices for the solution/project.

Quality gate review with structured findings and verdict. Use when: reviewing a completed implementation phase, checking spec compliance, convention adherence, test coverage, and issuing APPROVE or REQUEST_CHANGES verdicts.

Generate phased implementation blueprint with parallel research subagents. Use when: a clarified specification is ready for architecture planning, creating task tables, scoring complexity, and defining implementation phases.

Execute one implementation phase with progress tracking and verification. Use when: implementing tasks from an SDD plan, logging discoveries, updating task tables, and running build/test verification per phase.

Encode learnings from completed SDD cycles into the agent harness. Use when: a review has been approved and learnings need to be extracted, classified, and encoded into instruction files, copilot-instructions, or AGENTS.md.

Deep codebase research before feature specification — read-only exploration. Use when: starting a new SDD cycle, researching a feature or change before specification, gathering evidence about codebase patterns and constraints.

Create technology-free feature specification — WHAT and WHY, not HOW. Use when: writing a feature specification after the Explore phase, defining acceptance criteria and complexity scores, documenting goals and non-goals.

Generate structured GitHub Issue text from SDD spec and plan artifacts. Use when: a specification is complete and needs to be represented as a GitHub Issue for external tracking, sprint planning, or team visibility.

Deep design exploration for Workshop Opportunities identified in a specification. Use when: a spec has Workshop Opportunities that need detailed design analysis before clarification, or when a complex topic needs structured option evaluation.

Resolve specification ambiguities through targeted questions. Use when: a specification has NEEDS CLARIFICATION markers, open questions need resolution, or workflow mode and testing approach need to be decided.

Generate an Architecture Decision Record from SDD spec and clarifications. Use when: a feature requires decisions that outlive the feature itself, such as introducing a new datastore, changing a boundary, or adopting a pattern that becomes precedent.

Validate plan readiness before implementation with parallel quality gates. Use when: a plan has been created by the Architect phase and you want to verify completeness, doctrine compliance, and dependency ordering before starting implementation.

Build shared understanding by surfacing non-obvious insights from SDD artifacts. Use when: before complex implementation, after creating a spec or plan, when feeling uncertain about assumptions, or between the Architect and Implement phases.

Classic coding interview patterns including two pointers, sliding window, binary search variants, fast/slow pointers, prefix sums, interval merging, and monotonic stack. Use when: solving array or string problems under interview constraints, recognising which pattern fits a given input shape, implementing cursor-based pagination, analysing date-range or sorted time-series queries, reviewing LINQ chains for hidden complexity, or teaching pattern-first problem solving.

Scalability fundamentals, data partitioning, caching strategies, rate limiting, distributed systems patterns, and microservices data design — bridging classical DSA concepts to real production architecture decisions. Use when: designing or reviewing distributed system components, selecting a Cosmos DB partition key, implementing rate limiting or throttling policies, choosing caching strategies, analysing microservice communication patterns, or explaining CAP theorem trade-offs in the context of the Biotrackr architecture.

Core algorithm design paradigms including dynamic programming, greedy algorithms, divide and conquer, sorting, searching, and backtracking with decision guidance and trade-off analysis. Use when: selecting an algorithm paradigm for a new problem, teaching dynamic programming memoisation vs tabulation, reviewing greedy algorithm correctness, explaining divide-and-conquer recursion, analysing sorting algorithm choices, or recognising which algorithmic strategy applies to a given problem shape.

Big-O complexity analysis, recursion, foundational data structures, and problem decomposition for engineers without a formal CS background. Use when: analyzing algorithm complexity, performing Big-O analysis, selecting data structures, reviewing code for structural efficiency, teaching recursion fundamentals, or explaining time and space trade-offs.

Graph representations, BFS, DFS, topological sort, shortest path algorithms, and dependency analysis. Use when: teaching graph theory, analyzing service dependency topologies, implementing BFS or DFS traversal, detecting cycles in dependency graphs, performing topological ordering of tasks, or explaining directed acyclic graph (DAG) patterns in microservice or workflow architectures.

Arrays, strings, hash tables, linked lists, stacks, and queues — core linear data structures with complexity analysis, implementation patterns, and common problems. Use when: teaching linear data structures, reviewing code for data structure optimization, analyzing collection operation complexity, solving problems involving arrays or hash tables, implementing sliding window algorithms, or analyzing buffered/streamed data processing.

Binary trees, BSTs, heaps, priority queues, tries, and tree traversal patterns with complexity analysis and practical trade-offs. Use when: teaching tree or heap data structures, analyzing priority queue implementations, reviewing BFS or DFS traversal code, optimizing sorted collection usage, explaining BST vs heap trade-offs, or modeling hierarchical data.

Standardized report structure, recommendations, and reportlab PLATYPUS patterns for all Biotrackr health reports

Best practices for creating professional health data visualizations with matplotlib and seaborn

Biotrackr health data schema, metric extraction patterns, and analysis techniques for Fitbit activity data

WCAG 2.2 compliance, ARIA patterns, keyboard navigation, screen reader support, and inclusive design. Use when: reviewing accessibility, adding ARIA attributes, fixing contrast issues, implementing keyboard navigation, creating accessible forms, building accessible components, WCAG audit.

Front-end performance optimization including Core Web Vitals, render performance, asset optimization, and perceived speed. Use when: diagnosing slow page loads, optimizing Largest Contentful Paint (LCP), reducing Cumulative Layout Shift (CLS), improving Interaction to Next Paint (INP), bundle size analysis, lazy loading, caching strategies.

Mobile-first responsive design patterns, touch interaction guidelines, and adaptive layouts. Use when: designing for mobile viewports, implementing responsive breakpoints, optimizing touch targets, creating adaptive navigation, handling mobile-specific UX like swipe gestures or bottom sheets.

Web design fundamentals including layout systems, CSS architecture, design tokens, typography, and component-based UI patterns. Use when: building page layouts, creating design systems, structuring CSS, choosing layout approaches (grid vs flexbox), implementing design tokens, theming.