Results for “development”

Provides expert guidance on Development Containers (devcontainers) — creating, configuring, and optimising containerised development environments using the Dev Container Specification. This skill should be used when users ask about devcontainer.json, .devcontainer setup, Dev Container Features or Templates, pre-building images, multi-container workflows, Docker-in-Docker, cloud development environments (Codespaces, DevPod), or troubleshooting container performance and permission issues.

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

Accessible HTML game development for screen readers (Zhengdu, NVDA, JAWS). Supports blind and low-vision users. Trigger keywords: accessible game development, a11y game, 无障碍游戏开发.

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

Apply a Content Driven Development process to AEM Edge Delivery Services development. Use for ALL code changes - new blocks, block modifications, CSS styling, bug fixes, core functionality (scripts.js, styles, etc.), or any JavaScript/CSS work that needs validation.

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

Exploit development operational guide: environment setup, debugging workflow, PoC development lifecycle, writing reliable exploits, using pwntools/pwndbg, heap exploitation techniques, and weaponization considerations. Use when actively developing exploits or setting up an exploit dev environment.

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

Modern JavaScript/TypeScript development with Bun runtime. Covers package management, bundling, testing, and migration from Node.js. Use when working with Bun, optimizing JS/TS development speed, or migrating from Node.js to Bun.

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

Complete executive coaching system — leadership assessment, 360° feedback, coaching engagements, leadership development plans, team effectiveness, executive presence, and succession planning. Use for leadership coaching, executive development programs, team building, performance breakthroughs, and career transitions.

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

Delegate feature development, large code refactors, and pull request reviews to Codex, Claude Code, or OpenCode as background workers. Use isolated project checkouts, monitor progress, and arrange completion or failure notifications.

• Delegating feature development to a background worker
• Running a large code refactor in an isolated checkout
• Requesting a pull request review from a coding agent

Test an idea before committing to full development by building a small, disposable prototype. Compare approaches under equal conditions, try a failure case, and report feasibility with commands, results, or measurements supporting the verdict.

• Testing whether an idea is technically feasible
• Comparing two approaches under the same conditions
• Checking an edge case before full development

Finish completed development work by checking the full test suite and presenting integration choices: merge locally, create a Pull Request, or keep the branch. It carries out the selected path and handles workspace cleanup accordingly.

• Merging a completed feature locally
• Pushing a branch and creating a Pull Request
• Keeping completed work for later integration

Guides feature development and bug fixes by writing tests before implementation. It confirms each test fails for the expected reason, adds only enough code to pass, and checks the full test suite before completion.

• Implementing a new feature from tests
• Reproducing a bug in a test before fixing it
• Refactoring while keeping tests passing

Turn plans, specifications, or conversations into small development tickets that each deliver verifiable behavior. Identify which tickets must finish first, review the breakdown together, and publish approved tickets to local files or the configured issue tracker.

• Turn a specification into manageable development tickets
• Clarify ticket dependencies and execution order
• Plan a staged migration for a widespread refactor

Organize feature development using files in the repository. Break larger goals into user stories, assign them to sprints, guide implementation and review, and track progress through confirmed merges without an external project management tool.

• Plan feature delivery without an external project management tool
• Break requirements into implementable user stories
• Choose stories for the next sprint

Prepare and inspect plans for opening interactive commands in a visible WezTerm window while keeping the executable and arguments separate. Check terminal availability, preview launches as JSON, and use fallback or recovery modes when needed.

• Opening an interactive CLI in a new terminal window
• Starting an SSH session or local development process
• Inspecting a launch plan without opening a window

Guide development and debugging in Next.js 16 and later using Turbopack, a tool that bundles application code. Review slow startup, live updates, caching, webpack alternatives, bundle analysis, and version-specific proxy file naming.

• Investigating slow development server startup
• Checking delays in live updates after code changes
• Choosing between Turbopack and webpack

Guides electronic medical record development, covering visit workflows, prescriptions, and clinical data entry. Provides patterns for medication interaction alerts, abnormal result displays, audit trails, and accessible interfaces that keep patient information visible during care.

• Designing a patient visit workflow
• Adding medication interaction alerts
• Displaying abnormal laboratory results

Develop applications through separate planning, building, and evaluation agents. The workflow tests the running app, scores its design and functionality, and feeds specific issues back into repeated development cycles with configurable quality thresholds and iteration limits.

• Turning a brief idea into an application specification
• Refining frontend design through separate evaluation
• Testing and improving full-stack application features

Create and review Docker development environments, including service networking, persistent storage, and security settings. Also guides isolated testing of command-line installers on Linux, while identifying checks that require native macOS or Windows environments.

• Set up a local app, database, and Redis stack
• Review container networking and persistent storage
• Harden Dockerfile and Compose security settings

Coordinate parallel AI agent sessions with dmux, a tool that manages terminal panes. Split development, research, testing, or review into separate tasks, isolate overlapping file changes, and review results before merging them.

• Running research and implementation in parallel
• Splitting database, API, and UI work across agents
• Coordinating test monitoring and fixes

Coordinate parallel frontend, backend, or service development around one shared, machine-checkable interface specification. Generate consumer types, validate mocks and real responses against the same specification, and review changes together to prevent mismatched fields and incompatible integrations.

• Coordinating parallel frontend and backend development
• Aligning API or event formats across services
• Checking that mock and production responses match

Plan autonomous Claude Code workflows, from sequential development steps to parallel agents working from a specification. The material explains how to preserve progress between runs, check quality, coordinate merges, and set limits that stop repeated execution.

• Designing a sequential development pipeline
• Preserving progress across repeated agent runs
• Coordinating parallel work and merges

Expose a local development server or webhook receiver, which accepts notifications from external services, through Pinggy using SSH. Get a public sharing URL and add access controls without installing a separate tunneling program.

• Share a running development server
• Receive webhook callbacks locally
• Connect a remote client to a local HTTP MCP server

Delegate code changes and multi-step development tasks to OpenHands CLI using a model supported by LiteLLM, a connection layer for model providers. Run tasks without an interactive interface, inspect progress events, and resume previous conversations.

• Delegate code changes to OpenHands
• Run coding tasks with a LiteLLM-supported model
• Check progress on long-running development tasks

Turn recurring Claude Code tasks into reusable slash commands stored as Markdown files. The guidance covers arguments, file references, tool permissions, shell execution, and plugin integration so commands can run consistent, context-aware workflows.

• Turning recurring review instructions into a command
• Creating commands that accept file paths or issue numbers
• Sharing standard workflows across a project team

Create or improve skills for Claude Code plugins by defining clear activation conditions, writing focused instructions, and organizing supporting files. The guidance covers reusable scripts, reference documents, examples, and testing whether a skill activates for the intended requests.

• Creating a new skill inside a plugin
• Clarifying when an existing skill should activate
• Splitting long instructions into reference files