Results for “boundaries”

Ensure architecture/design docs define clear boundaries, ownership, dependency direction, and change impact to avoid tight coupling.

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

Manages agent isolation levels and resource boundaries. Specifies concrete controls and the evidence needed to assess their boundaries. Activate on 'isolation level', 'agent isolation', 'resource boundaries', 'sandboxing', 'agent containment'. NOT for permission validation (use dag-permission-validator) or runtime enforcement (use dag-scope-enforcer).

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

Identifies domain modules, ownership boundaries, dependencies, and interfaces using Domain-Driven Design principles. Provides domain maps, bounded contexts, refactor recommendations. Use for "DDD", "domain modeling", "bounded contexts", or "service boundaries".

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

Set up dependency-cruiser in a TypeScript project to enforce package boundaries, keep internal files private, and detect circular dependencies. Includes an example package, verification of the rules, and documentation for future development.

• Preventing direct imports of package internals
• Checking boundaries alongside type checks
• Creating a reusable package template

Plan and verify security controls for AI agents that read untrusted content and use tools. Review permissions, file boundaries, network destinations, and credentials, then test that rejected actions leave no unintended changes.

• Reviewing security boundaries in an agent runtime
• Checking isolation between tenants and workspaces
• Testing credential cleanup and tool output limits

Build and review React 18/19 components with guidance on state management, data fetching, forms, loading states, and error handling. It also covers keyboard access and how to divide components between server and browser execution.

• Reviewing React components
• Choosing where shared state belongs
• Designing forms and data fetching

Design an OpenClaw agent persona from preferences or random draws. Build a consistent background, personality, behavioral boundaries, name, SOUL.md and IDENTITY.md files, plus an avatar prompt, with optional image generation through an approved skill.

• Creating an OpenClaw persona from scratch
• Exploring character ideas through random draws
• Completing a rough persona with a name and boundaries

Design or refactor services so business rules stay separate from databases, APIs, and frameworks. Uses Ports and Adapters—interfaces and their implementations—to define clear boundaries, test workflows, and migrate existing code one feature at a time.

• Separating business rules from database and API calls
• Sharing application workflows across HTTP, CLI, and workers
• Replacing infrastructure while preserving business rules

Structure Android and Kotlin Multiplatform projects with clear boundaries between business logic, screens, and data access. Provides examples for module dependencies, business operations, repositories that coordinate data sources, database integration, and error handling.

• Planning Android or KMP module boundaries
• Separating business logic from screen code
• Coordinating local and remote data sources

Design APIs and interfaces between modules with clear inputs, outputs, naming, and errors. The skill guides compatible extensions, input validation, and retry handling so callers can use interfaces consistently without accidentally repeating state-changing operations.

• Designing new REST endpoints
• Defining frontend and backend data contracts
• Extending an API while preserving compatibility

Compare a PPTX exported from HTML with its source slides to find cropped text, footer overlaps, and lost styling. Identify shared causes, revise layout rules, and re-export the deck with automated checks for content extending beyond slide boundaries.

• Check an HTML slide deck against its exported PPTX
• Fix cropped text and footer overlaps
• Investigate missing italics and unexpected fonts

Restructure claude-flow v3 into focused modules using Domain-Driven Design, which groups code by responsibility. Define module boundaries, event communication, and plugin interfaces to support a modular architecture with independently testable business logic.

• Split an oversized orchestrator into focused modules
• Define boundaries between tasks, sessions, and monitoring
• Design plugin extensions and domain events

Review Homecore plugins by distinguishing built-in native code from external Wasm packages. Check signatures, publisher identity, paths, resource limits, and host permissions, then use the documented verification command to assess the plugin’s trust boundaries.

• Review an external Wasm plugin before use
• Check built-in native plugin registration
• Inspect plugin resource limits and host permissions

Turn an approved specification into pseudocode, a plain outline of program logic, and an architecture defining module responsibilities and API inputs and outputs. After user confirmation, proceed with implementation and unit tests based on those designs.

• Turning an approved specification into pseudocode
• Defining module boundaries and dependency rules
• Designing API inputs, outputs, and error responses

Audit a TypeScript codebase organized with domain-driven design, which separates business responsibilities into distinct areas. Identify improper imports, unchecked data changes, event issues, and repository placement problems, then report their locations and suggested fixes.

• Auditing dependencies between business domains
• Reviewing cross-module changes before merging
• Checking domain boundaries in continuous integration

Restructure claude-flow v3 into focused modules using Domain-Driven Design, which groups code by responsibility. Define module boundaries, event communication, and plugin interfaces to support a modular architecture with independently testable business logic.

• Split an oversized orchestrator into focused modules
• Define boundaries between tasks, sessions, and monitoring
• Design plugin extensions and domain events

Plan HyperFrames videos so motion flows continuously between scenes. Match movement direction and speed across cuts, connect actions through visible causes, and verify scene boundaries while keeping each scene active through meaningful reveals or interactions.

• Plan consistent movement across scene transitions
• Connect scenes with a shared visual element
• Replace idle motion with reveals or interactions

Design the operating layer around a coding agent so it can read and edit code, run checks, and correct errors. Define completion criteria, permission boundaries, feedback, and recovery methods, and assess which tasks suit autonomous execution.

• Designing a coding agent's tools and workflow
• Adding acceptance checks and permission boundaries
• Assessing tasks for autonomous agent execution

Implement or review login and access controls for applications and APIs. Helps define token lifetimes, session handling, and permissions for specific resources, with checks for user identity, organization boundaries, credential storage, and authentication failures.

• Implement login and session management
• Review access controls for REST or GraphQL APIs
• Design social login or single sign-on

Helps contributors develop and fix Airflow’s Java SDK for JVM tasks. Explains public API boundaries, JAR packaging, Python coordination, communication schema updates, and the test commands used to validate changes.

• Adding features or fixing bugs in the Java SDK
• Reviewing public API and internal implementation boundaries
• Investigating JAR discovery and JVM startup failures

Analyze a custom protocol in a CTF sandbox and reproduce an accepted exchange. Recover message boundaries, checksums, and session state, then build a small replay program that preserves the required message order.

• Recover message boundaries in an unknown protocol
• Reconstruct handshake steps and session state
• Build a replay program for a captured exchange

Analyze Android apps in a CTF sandbox using static inspection and Frida hooks, which observe or alter running code. Trace request signing, local storage, and Java-to-native boundaries to reproduce a request accepted by the server.

• Tracing request-signing inputs and outputs
• Inspecting Java-to-native calls with runtime hooks
• Examining app settings, databases, and token storage

Set up and organize an Nx monorepo, a shared repository for multiple applications and libraries. Define dependency boundaries, configure build caching, and use affected commands to focus CI tasks on projects impacted by changes.

• Setting up a new Nx workspace
• Defining dependencies between applications and libraries
• Running CI tasks only for affected projects

Add Markstream to AI chat or document interfaces to render Markdown as it arrives. The skill selects the framework package and configures dependencies, styles, streaming behavior, and server-side rendering boundaries.

• Add streaming Markdown to an AI chat interface
• Fix missing styles or server-side rendering errors
• Replace an existing Markdown renderer with Markstream