Reviews implementation plans from the perspective of AI agent system design. Use when evaluating whether the implementation correctly handles long-running agentic invocations, context window management, session continuity, partial output handling, and the mechanics of building reliable multi-step agent loops.
Reviews implementation plans from a software architecture perspective. Use when evaluating module structure, separation of concerns, dependency direction, extensibility points, and whether the proposed design will age well.
Reviews implementation plans from a clap and CLI framework perspective. Use when evaluating argument parser design, subcommand structure, derive vs. builder API choices, help text generation, shell completion integration, and clap-specific patterns.
Reviews implementation plans from a cross-platform compatibility perspective. Use when evaluating Linux vs. macOS behavioral differences, signal handling portability, filesystem semantics, terminal detection, and anything that might work on one platform but break on another.
Reviews implementation plans from a dependency management perspective. Use when evaluating crate selection, dependency minimization, supply chain risk, feature flag hygiene, and whether new dependencies are justified.
Reviews implementation plans from a technical writing and documentation perspective. Use when evaluating whether planned features can be clearly explained, whether help text will be sufficient, whether error messages are teachable, and whether the implementation will produce good documentation surfaces.
Reviews implementation plans from an error handling design perspective. Use when evaluating error type design, anyhow vs. typed errors, error propagation strategy, error message quality, and whether failures are handled at the right level.
Reviews implementation plans from a filesystem and I/O perspective. Use when evaluating atomic writes, file locking, path handling, directory traversal, permission management, and cross-platform filesystem behavior.
Reviews implementation plans from a memory management perspective. Use when evaluating heap allocation patterns, unbounded growth risks, streaming vs. buffering tradeoffs, and whether the implementation will remain stable across long-running workflows with hundreds of cycles.
Reviews implementation plans from a performance and efficiency perspective. Use when evaluating algorithmic complexity, unnecessary allocations, hot path analysis, benchmarking strategy, and whether performance-sensitive operations will scale to realistic workloads.
Reviews implementation plans from a process management perspective. Use when evaluating subprocess spawning, stdin/stdout/stderr piping, signal forwarding, PID tracking, timeout implementation, and cross-platform process behavior.
Reviews implementation plans from a regex and pattern matching perspective. Use when evaluating completion signal detection, cost extraction patterns, error classification matchers, custom parser design, ReDoS risk, anchoring correctness, and whether regex patterns are testable and maintainable.
Reviews implementation plans from the perspective of an experienced Rust developer. Use when evaluating idiomatic Rust patterns, trait design, ownership and borrowing, lifetime annotations, and whether the proposed implementation structure will fight the borrow checker.
Reviews implementation plans from a serialization and data format perspective. Use when evaluating serde usage, TOML/JSON schema design, on-disk format evolution, backward compatibility, and whether structured data is being handled safely.
Reviews implementation plans from a testing strategy perspective. Use when evaluating test coverage, mock design, unit vs. integration test balance, test isolation, and whether the proposed implementation will be easy or hard to test.
Reviews plans and specs from the perspective of someone building AI agent systems and agentic workflows. Use when evaluating whether rings is a good substrate for autonomous agents, multi-agent coordination, long-running agentic tasks, and human-in-the-loop patterns.
Reviews plans and specs from the perspective of a developer who is competent with software but new to AI-assisted programming workflows. Use when evaluating first-run experience, error clarity, mental model legibility, cost visibility, and onboarding friction.
Reviews plans and specs from the perspective of a Unix and CLI best practices expert. Use when evaluating command design, flag conventions, composability, signal handling, and whether the tool will feel at home in a Unix workflow.
Reviews plans and specs from the perspective of a data engineer and ETL pipeline builder. Use when evaluating data lineage, idempotency, failure recovery, phase contracts, format stability, and replay/backfill capabilities.
Reviews plans and specs from the perspective of a DevOps engineer focused on observability and operations. Use when evaluating structured output, metrics, tracing, log quality, operational runbooks, and whether the tool behaves well under process management.
Reviews plans and specs from the perspective of an enterprise security and compliance reviewer. Use when evaluating audit trail completeness, credential handling, data residency, access control, retention policies, change management, and third-party data sharing.
Reviews plans and specs from the perspective of a cost-conscious startup founder who uses AI tooling at scale. Use when evaluating spend visibility, budget control reliability, early warnings, runaway protection, cost predictability, and ROI signal.
Reviews plans and specs from the perspective of a Gen Z developer with strong DX instincts and low tolerance for friction. Use when evaluating first impressions, copy-paste friendliness, cognitive overhead, aesthetic quality of output, and whether the tool feels modern and well-crafted.
Reviews plans and specs from the perspective of an experienced open source maintainer. Use when evaluating API stability, semver discipline, contributor onboarding, format versioning, dependency footprint, and long-term maintenance burden.