Results for “development”

Drafts U.S. commercial real estate owner-developer agreements covering scope, entitlements, schedule, pricing (fixed, GMP, cost-plus), change orders, payment and retainage, insurance, indemnity, IP, confidentiality, termination, and disputes. Use when user mentions "development agreement", "owner-developer agreement", "project development contract", "real estate development", "GMP", "cost-plus", "milestones", or "change orders".

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

Configure and troubleshoot Vite projects, covering environment variables, API proxies, plugins, and production builds. The skill also guides library packaging, dependency compatibility, and development server performance, with checks for exposed secrets and missing TypeScript validation.

• Configuring environment variables and development API proxies
• Investigating slow development servers and update failures
• Optimizing production bundles and checking builds

Turn product requests and planning documents into a concrete development plan. Document business rules, data ownership, service interfaces, and unresolved decisions so teams can see what must be settled before implementation begins.

• Turning a product requirements document into development requirements
• Aligning requirements for a feature spanning multiple services
• Documenting assumptions that repeatedly surface in reviews

Coordinate feature work, bug fixes, refactoring, and MVP development through shared phases scaled to the change. Related operation skills use this workflow to delegate research, planning, test-first implementation, review, and commits with human approval checkpoints.

• Using a shared process for feature additions and bug fixes
• Scaling development steps to the size of a change
• Organizing MVP development from a design document

Establish a Git workflow for team development, from choosing branches for separate changes to writing clear commits and pull requests. Includes history cleanup, merge versus rebase decisions, conflict resolution, and release tagging.

• Choosing a branching strategy for a new project
• Standardizing commit messages and pull request descriptions
• Tidying local commit history before a pull request

Set up reproducible development environments with Flox on macOS and Linux. Define tools, package versions, setup steps, and local services in one configuration, then share it with teammates or add project-specific tools for AI agents.

• Sharing a consistent development setup across a team
• Combining language tools and system dependencies
• Running local PostgreSQL and Redis services

Guide development through test-driven development (TDD): write a test, confirm it fails, add minimal code, then clean up. Apply this cycle to features and bug fixes while checking that existing behavior still passes its tests.

• Adding features with tests written first
• Reproducing a bug in a test before fixing it
• Refactoring while keeping tests passing

Define project quality standards in CONSTRAINTS.md, connect measurable targets to checks, and inspect changes for weakened safeguards. It helps teams choose thresholds and catch skipped tests, suppressed warnings, unfinished code, or lowered standards during agent development.

• Set quality standards before starting agent development
• Choose coverage and performance thresholds
• Detect skipped tests and suppressed warnings

Build a narrative project history from records stored in claude-mem. The report traces architectural changes, breakthroughs, debugging efforts, and work patterns, with timeline statistics and estimates of token savings from reusing recorded knowledge.

• Reviewing a project's development history
• Tracing architectural decisions and their consequences
• Examining recurring debugging and work patterns

Organize software development from requirements and architecture through testing, review, and deployment. Use specialized agent roles, shared memory, and test-driven development, where tests are written before code, to coordinate work across the project.

• Plan and implement a new feature
• Refactor legacy code with supporting tests
• Review code security and performance

Automate checks, code formatting, agent coordination, and session records around Claude Code operations. Uses hooks, actions triggered before or after work, to preserve context and connect development tasks with shared memory.

• Automatically format and validate edited code
• Share progress across multiple agents
• Save and restore development sessions

Guide Rust development through test-driven development: write a failing test, implement enough code to pass, then refactor. Includes practical test patterns and final checks for formatting, static analysis, and test results.

• Adding Rust features with tests first
• Reproducing bugs with failing tests before fixing them
• Testing invalid inputs and error paths

Review recent Claude Code chats to identify development strengths, recurring difficulties, and learning priorities. Receive a personalized report with practical recommendations and relevant HackerNews articles, delivered to your own Slack direct messages.

• Reviewing development habits from recent chats
• Prioritizing recurring technical difficulties
• Finding learning articles relevant to current work

Automate checks, code formatting, agent coordination, and session records around Claude Code operations. Uses hooks, actions triggered before or after work, to preserve context and connect development tasks with shared memory.

• Automatically format and validate edited code
• Share progress across multiple agents
• Save and restore development sessions

Organize software development from requirements and design through testing, review, and deployment. Uses Claude Flow to coordinate specialized agents, share decisions across sessions, and guide implementation with tests written before code.

• Developing a feature from requirements through review
• Refactoring legacy code with supporting tests
• Investigating bugs and adding regression tests

Coordinate multiple AI agents for research, development, testing, and system analysis using Claude Flow. Choose how agents communicate, assign specialist roles, combine parallel and sequential tasks, and monitor progress through reporting and recovery workflows.

• Divide research, analysis, and report writing among agents
• Coordinate application development across specialist agents
• Run multiple types of tests in parallel

Set up a new Remotion Element for development in the documentation’s Remotion Studio. It follows the design and contribution guides, creates the starting structure, and offers to launch Docs Studio for a preview.

• Starting development of a new Remotion Element
• Preparing an Element with the official guides
• Previewing a scaffolded Element in Docs Studio

Plan game development workflows by matching engines, art and audio tools, automated playtests, packaging, publishing, and analytics to available tools and credentials. Compare options by cost, quality requirements, and offline availability.

• Plan a small Godot game for a game jam
• Combine AI-generated art with a simple game loop
• Choose tools for automated agent playtesting

Run one iteration of a BMad unattended development loop, with optional route and review selections. The skill follows a generated workflow and reports a halt reason or command failure when execution cannot continue.

• Running one unattended development iteration
• Selecting the oneshot or full route
• Choosing none, quick, or thorough review

Run repeatable tests of Cherry Studio’s key workflows with Playwright, which checks application behavior through automated interactions. Collect results on macOS and Windows and produce English reports for release acceptance or development validation.

• Checking key workflows before a release
• Validating application behavior on a development branch
• Running regression tests for a specific task

Guide cross-platform app development with Avalonia UI and Zafiro using consistent architecture and coding conventions. Keep screen logic separate from UI dependencies, handle errors explicitly, and reuse existing helpers with ReactiveUI and DynamicData.

• Align design conventions for an Avalonia UI app
• Keep ViewModels independent of Avalonia
• Review error handling with Result types

Design mock APIs, simulated services that reproduce expected responses, authentication, errors, and delays. Define scenarios and repeatable test data to support frontend development, integration testing, and realistic demos before the real backend is ready.

• Developing a frontend before the backend is ready
• Simulating a partner or third-party API
• Preparing a demo with realistic API responses

Plan and develop Android apps with guidance on technology choices, app structure, screen design, testing, debugging, performance, and releases. Covers native Kotlin and Java development alongside Flutter, RN, KMM, and hybrid approaches.

• Choosing an Android development stack
• Planning app structure and screen design
• Investigating crashes and memory issues

Coordinate multiple Claude Code workers through an existing Kanban board. This guide describes task dispatch, automated checks before AI review, per-task cost tracking, human intervention, and recovery after restarts; the runtime and integrations require separate installation.

• Coordinating multiple Claude Code workers
• Running automated checks before AI code review
• Monitoring task progress and development costs on a board