Results for “standards”

Enforces project coding standards during code review: naming conventions (PascalCase for classes, camelCase for methods/variables, UPPER_SNAKE_CASE for constants, kebab-case for files), standard file structure, anti-magic-number policy, file size limits (500/800 lines), security patterns, and design patterns. Use when reviewing code, writing new code, or checking adherence to project conventions.

The English summary is being prepared. Showing the original description.

Establish and enforce coding standards, best practices, and architectural patterns across the codebase using linters, formatters, and code review processes. Use when setting up ESLint/Prettier, configuring linting rules, creating code style guides, implementing pre-commit hooks, establishing naming conventions, enforcing TypeScript strict mode, maintaining consistency, conducting architecture reviews, or defining team coding standards.

The English summary is being prepared. Showing the original description.

Write and review Java services using conventions for naming, immutable data, exception handling, project structure, and tests. Detects Spring Boot or Quarkus from build files and applies the relevant framework rules.

• Reviewing Java code for consistent conventions
• Checking Optional and stream usage
• Organizing packages and project structure

Write, review, and refactor modern C++ using the C++ Core Guidelines. Covers type safety, automatic resource cleanup, class design, exceptions, concurrency, and naming conventions, with examples and a checklist for identifying unsafe or inconsistent code.

• Writing modern C++ classes and functions
• Reviewing memory ownership and resource cleanup
• Refactoring existing C++ code

Review interface animation code for timing, natural movement, responsiveness, rendering performance, and accessibility. Receive a table of specific problems, suggested changes, and reasons, followed by a clear decision on whether the motion meets the review standards.

• Reviewing dropdown and tooltip transitions
• Checking responsiveness during repeated interactions
• Finding animation patterns that may hurt rendering performance

Organize ISO evidence for medical devices and laboratories, including controlled documents, risk records, corrective actions, and supplier controls. Produce structured gap reports for authorized human review while keeping certification, accreditation, and regulatory processes distinct.

• Organize controlled documents and implementation records
• Check links in medical-device risk and design records
• Review corrective-action and supplier-control evidence

Customize AgentRC readiness assessments to match team or organization standards. Choose or create policies that adjust check importance, disable irrelevant checks, set pass thresholds, and define requirements for automated checks in CI workflows.

• Set shared readiness standards across an organization
• Focus assessments on AI tooling
• Adjust the importance of individual checks

Review completed code changes for defects, security risks, unnecessary complexity, and missing tests. Findings are verified and reported with severity, file locations, and concrete failure scenarios, with separate assessments of standards and intended behavior for larger changes.

• Checking completed changes before release
• Reviewing compliance with documented development standards
• Checking implementation against ticket requirements

Apply consistent coding practices across TypeScript, JavaScript, React, and Node.js projects. Get guidance on naming, types, error handling, API design, file organization, and tests to make code easier to read and maintain.

• Aligning coding conventions across a team
• Refactoring long functions and deeply nested code
• Reviewing React components and state updates

Audit websites for accessibility barriers and improve image descriptions, color contrast, forms, keyboard navigation, and screen reader support. Provides code examples and automated and manual testing guidance for work toward WCAG 2.1 AA or AAA accessibility standards.

• Auditing a website for accessibility issues
• Fixing form labels and error announcements
• Checking keyboard navigation and dialog focus

Reviews pull requests for bugs, error handling, code quality, and style consistency. Organizes feedback into an overview, must-fix issues with file locations, improvement suggestions, and positive notes so reviewers can distinguish urgent problems from refinements.

• Finding bugs that must be fixed before merging
• Reviewing TypeScript types and asynchronous code
• Checking naming, imports, and leftover debug statements

Create and apply brand guidelines for colors, fonts, logos, imagery, and writing tone. Review materials for consistency and produce practical references, including palette tables, typography specifications, tone examples, and a concise guide for collaborators.

• Create a concise brand guide for contractors
• Check slides and social graphics for brand consistency
• Define writing tone for different situations

Review REST API specifications with automated checks for inconsistent conventions and breaking changes—changes that disrupt existing clients. Get a design grade, improvement recommendations, and tool reports to support release reviews and API migrations.

• Reviewing a pull request that changes API endpoints
• Checking compatibility before an API version migration
• Establishing shared API design standards

Create a game's art direction document, defining its visual rules, mood, shapes, colors, and production standards. Review and approve sections individually, with guidance that connects character, environment, and interface design to the game's concept and technical constraints.

• Defining a game's core visual identity before asset production
• Documenting character, environment, and interface design rules
• Aligning asset standards with engine and performance limits

Review game code for architecture, coding standards, testability, and performance concerns. Get findings tied to specific code, checks against recorded design decisions, and a report separating required fixes from optional improvements.

• Reviewing game code before closing a development task
• Checking implementation against recorded architecture decisions
• Finding testability gaps and performance concerns

Review code changes or a pull request for bugs, effects on existing behavior, test gaps, and project standards. Receive findings supported by the code and a clear account of review coverage, with local fixes available when explicitly requested.

• Reviewing a pull request before release
• Checking changes for bugs and test gaps
• Applying review findings locally

Find CAD models of off-the-shelf parts on step.parts using model names, standards, aliases, and dimensions. Compare matching records, download STEP files when needed, and check file integrity against a supplied checksum.

• Find a servo or motor by model number and aliases
• Compare screws and bearings by standard and dimensions
• Download a selected STEP file and check its integrity

Prepare new hires' onboarding from Google Workspace group records and documented role standards. Plan accounts and memberships, invite hires to Slack channels, and create first-week Linear checklists, while holding Workspace access changes for human approval.

• Prepare accounts and first-week tasks before a new hire starts
• Choose groups and Slack channels using role and team standards
• Track account creation and memberships awaiting approval

Structure TypeScript backend features with clear module boundaries, shared definitions, and focused tests. It guides implementation and reviews while keeping request handling in routes and business logic in services.

• Adding a backend feature with consistent module organization
• Separating request handling from business logic
• Reviewing shared types and utilities

Organize React and TypeScript frontend code using consistent rules for feature folders, shared components, types, API access, and tests. Use it to guide new code, focused refactoring, and reviews of existing changes.

• Adding a frontend feature with consistent file organization
• Reviewing shared components and type placement
• Refactoring imports and module exports

Set up a commercial contracts assistant around your team's review standards and approval rules. The interview creates an editable practice profile and can compare stated negotiation positions with terms found in signed agreements.

• Setting up a commercial contracts assistant for the first time
• Documenting contract review standards and approval rules
• Comparing stated policies with signed contract terms

Review token contracts and the protocols that accept them for ERC20/ERC721 compliance, privileged controls, and unusual transfer behavior. Produces evidence-based risk assessments and prioritized fixes, with supply and holder analysis when deployed contract details are provided.

• Checking ERC20/ERC721 implementations against their standards
• Reviewing support for tokens with unusual transfer behavior
• Assessing administrator powers and upgrade risks

Turn product management notes or workshop material into a structured skill, or update an existing one. Follow a workflow covering duplicate checks, drafting, validation, catalog updates, and optional ZIP packaging for upload.

• Turning workshop notes into a product management skill
• Updating a skill while preserving repository standards
• Checking structure and metadata before committing

Review Python changes against shared team standards to find bugs, missing regression tests, and security issues. Findings are ordered by severity and include file names and line numbers so reviewers can locate each problem.

• Reviewing Python changes before merging
• Checking that bug fixes include regression tests
• Finding unsafe SQL and exposed secrets