newt

Audits UI code and markup for WCAG compliance and practical usability.

Produces a deterministic ADR draft suitable for pasting into your repo's ADR directory.

Performs deterministic architecture validation against Clean, Hexagonal, Layered, Modular Monolith, and Microservices blueprints. Ideal for early warning during large refactors.

Runs a deterministic, high-signal brainstorming session that generates options and converges to a small number of testable candidates. Produces decision artifacts (Idea Cards, ADR Draft, Experiment Brief) and logs the session.

Reviews an existing component (or drafts a new spec) with a focus on web UI best practices.

Takes an existing set of ideas (from a brainstorming session, doc, or chat) and converges it deterministically using the configured rubric.

Creates a lightweight design system spec that teams can implement incrementally.

Turns a selected candidate into an executable experiment plan with instrumentation, rollout strategy, and kill criteria.

Executes specific Newt hooks with configurable options. Hooks provide automated quality checks, security validation, and intelligent code assistance.

Installs Newt hooks for Git, IDE, and CI/CD integration. Hooks provide automated quality checks, security validation, and intelligent code assistance throughout the development workflow.

Lists all currently installed Newt hooks across Git, IDE, and CI/CD categories. Shows enabled/disabled state, thresholds, and last execution time for each hook.

Provides a health dashboard for all installed Newt hooks. Shows execution counts, success rates, last run times, and any configuration or permission issues.

Executes one or more hooks in dry-run mode against the current working tree. No files are modified, no commits are blocked, and no external systems are notified. Useful for validating hook configuration before enabling blocking mode.

Safely removes Newt hooks from the target environment. Restores any pre-existing hooks that were overwritten during installation.

Validates `.newt/hooks.yml` and all related hook configuration against the Newt schema. Reports errors (which prevent hook execution) and warnings (which may cause unexpected behavior).

Triggers the PR review agent ecosystem to analyze code changes, suggest optimal commit boundaries, plan PR structure, and generate human-readable communications. Supports multiple modes from live development to massive PR handling.

Provides an executive dashboard of the repository's quality signals. Useful for release planning, quarter planning, or onboarding new contributors.

Automatically refreshes the Newt plugin in Windsurf/Cursor whenever the repository is updated. This ensures you always have the latest version of the plugin without manual reinstallation.

Reviews responsive UI implementation and proposes fixes for layout, spacing, and stability.

Reads markdown logs from `logs/reviews/` and summarizes past findings so teams can monitor trends and verify remediation progress.

Triggers a repository-wide code review that fuses architecture, security, performance, and maintainability insights. Ideal for pull request validation or pre-release gates.

Creates a complete UI design and implementation plan for a page/flow or feature, aligned to the detected web stack.

Analyzes a user flow (or screen) for UX anti-patterns and recommends improvements.

Evaluates repository topology and enforces architectural fitness across popular enterprise styles.

Primary facilitator for Newt's Ideation OS; runs structured ideation, clustering, scoring, and produces decision artifacts.

Identifies explicit/hidden constraints and assumptions; proposes constraint relaxation options to expand the solution space safely.

Scores and selects the best ideas using a deterministic rubric; outputs top candidates and clear trade-offs.

Cross-domain inspiration agent that proposes analogies, patterns to borrow, and modern practices to adapt.

Turns a selected candidate idea into a testable experiment plan with instrumentation, rollout strategy, and kill criteria.

Designs and reviews web UIs for usability, accessibility, responsiveness, and performance using UX best practices and modern frontend patterns.

Identifies runtime efficiency risks spanning algorithms, memory usage, blocking calls, and database queries.

Human interface specialist that generates natural language PR descriptions, review comments, and stakeholder communications tailored to different audiences and contexts.

Strategic planning agent that analyzes code changes to suggest optimal commit boundaries, PR splits, and review sequences for complex development workflows.

Continuous development companion that provides real-time review suggestions, PR planning, and intelligent code quality assurance throughout the entire development lifecycle.

Master coordinator that drives cross-agent AI code analysis and produces an executive-quality review package.

OWASP-aligned sentinel focused on injection, secrets exposure, dependency risk, and authN/Z correctness.

Analyze headings, landmarks, and primary CTA clarity to improve visual hierarchy and scannability in web UIs.

Validate that the repository is in a clean, buildable state before CI/CD pipeline execution.

Analyzes staged changes to suggest optimal commit boundaries and logical groupings.

Check UI component consistency for spacing, color tokens, typography scale, and variant duplication.

Extracts explicit and implicit constraints from configuration changes and architecture findings to keep an up-to-date constraints register.

Check project dependencies against known vulnerability databases and flag packages with critical or high CVEs.

Validate deployment configuration and readiness checks before production or staging deployments.

Detect common web accessibility issues (WCAG-oriented) in UI files and suggest deterministic fixes.

Identify circular module dependencies that destabilize builds and violate architectural layering.

Detect oversized classes or modules that violate single-responsibility principles.

Scan query-building code for unsafe string concatenation or unparameterized input handling.

Analyze and suggest improvements to Newt hook configuration based on project type, team size, and observed execution patterns.

Execute Newt hooks in response to Git, IDE, or CI/CD events with configurable thresholds and blocking behavior.

Monitor hook execution patterns, detect failures, and surface health degradation across Git, IDE, and CI/CD hooks.

Validate hook configuration files against the Newt schema and surface errors that would prevent correct hook execution.

Converts recurring review findings and logged risks into structured opportunity statements and backlog items.

Clusters brainstormed ideas into themes and computes theme-level scores for faster convergence.

Provides real-time inline code suggestions and quality feedback as developers work in their IDE.

Detect performance regressions in code changes by analyzing algorithmic complexity, resource usage patterns, and known anti-patterns.

Automatically analyzes large PRs and suggests optimal splits into manageable, logical sub-PRs.

Analyze responsive breakpoints, media queries, and layout stability risks (CLS) in web UI code.

Detect secrets, credentials, API keys, tokens, and other sensitive values accidentally committed to the repository.

Detect potential UX anti-patterns in UI text and structure and suggest user-friendly alternatives.