
workflow-skills
Skills for AI agent workflow and requirements clarification processes.
- GitHub stars
- 69
Install
/plugin install workflow-skills@awesome-ai-agent-skillsRun it inside Claude Code after adding the marketplace with /plugin marketplace add thienanblog/awesome-ai-agent-skills.
Contents
Discovered from sourceSkills 15
AGENTS.md Generator
Produce a small instruction layer containing verified project facts that materially change agent behavior. General engineering knowledge belongs outside always-loaded instructions.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Discover the instruction chain
Inspect existing instructions, their ownership, scopes, and symlinks before editing. Preserve a working shared source such as AGENTS.md pointing to CLAUDE.md; do not replace it solely to impose a preferred filename. Add compatibility files only when the requested tool support needs them. Keep global user configuration outside a repository-instruction task.
For an unfamiliar or multi-tool repository, the bundled detector can locate instruction paths and declared framework/tool signals:
"<skill-directory>/scripts/detect-agent-context" --root "<repository-root>" --format json
On Windows use scripts/detect-agent-context.cmd with the same arguments. Python provides JSON; native Bash/PowerShell fallbacks emit a smaller text report. Resolve scripts relative to this skill, not the target project. Direct file inspection is sufficient for a known, narrow edit.
The detector indexes selected public manifests and instruction/config paths without reading credentials, environment files, or instruction contents. Treat it as an index: read the applicable instructions and verify commands in their source before persisting them. Include global paths only when that investigation is authorized and relevant.
Read discovery.md for detector details or tool-compatibility.md when loading order and supported tool behavior affect the output.
Select durable rules
Keep a rule when it is non-obvious, supported by project evidence, useful across tasks, and concrete enough to follow. Good candidates include exact command runners, generated-file ownership, unusual business boundaries, required checks, and repository-specific deployment or approval constraints.
Remove or rewrite generic advice, personas, duplicated rules, obsolete commands, exhaustive inventories, mandatory questionnaires, unsupported scores, and procedures that conflict with current project intent. Describe actual authorization boundaries; do not invent new approval gates or weaken explicit ones.
Keep detailed design, API, testing, and deployment guidance in their existing owners, linked with a clear read condition. Exclude secrets, home-directory paths, prompt transcripts, task logs, and global tool inventories.
Write or reconcile
Default to one compact shared instruction source. Use nested files for meaningful scope differences supported by the target tools, without repeating parent rules. For Codex, check same-directory AGENTS.override.md precedence before proposing a layout. For requested Claude compatibility, an import or existing symlink can avoid duplicate rules.
Use output-template.md as a menu. Classify existing content as keep, update, move, remove, or unresolved; resolve facts from source, and ask only about conflicts that require the user's decision. Read merge-and-verify.md for an existing file consolidation.
Prefer roughly 80–150 lines for a root file and shorter scoped files, without padding to a target. Review a root above 200 lines or 16 KiB for duplication and misplaced detail; preserve justified requirements while respecting the target tool's actual loading limit. Do not raise a global context limit just to avoid editing.
Use tracked diffs for recovery. Preserve untracked content that would otherwise be lost. Do not create routine backup copies, alter history, or ignore entire tool-configuration directories merely as part of generating instructions.
Verify
Check cited paths and commands, scope/precedence, symlinks, duplicate rules, and unresolved placeholders. Measure line/byte size and ensure the relevant instruction chain fits the target tool. Run repository validators when applicable. Static inspection of a command does not mean it was executed; do not run a destructive command to verify its spelling.
Report material rules kept, changed, moved, or removed, the evidence used, and unresolved conflicts. Avoid a separate discovery report unless the user requested it.
Brainstorm First
Turn uncertainty into a useful decision. Compare approaches against the user's actual goal and constraints, and challenge an impractical request with concrete evidence.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Investigate enough to compare
Inspect supplied artifacts, relevant project sources, and authoritative documentation before asking for facts already available. Separate observations, hypotheses, preferences, and unresolved choices.
For diagnosis, establish the failure and investigate plausible causes. Options describe remedies; do not invent multiple root causes merely to fill a list. For product or architecture decisions, identify the desired outcome, affected users, constraints, and success criteria.
Ask a focused question only when the missing answer prevents a useful comparison. Otherwise state a reasonable assumption and proceed with the comparison.
Present useful alternatives
Honor the requested number of options. Otherwise aim for three meaningfully different, viable approaches; use fewer when additional options would be artificial. For each, explain:
- the approach and how it addresses the goal;
- its main benefit, cost, limitation, and prerequisite;
- the evidence and uncertainty that could change the decision.
Use comparable criteria, and recommend one with a short rationale. Give numerical scores only when requested or when an agreed measurement rubric makes them useful. Do not invent precision for subjective judgments.
Respect the decision boundary
When the user requested options for selection, present the comparison and wait before implementation. Read-only investigation and requested temporary previews are allowed during that phase. If the user already authorized choosing and implementing the best approach, explain the choice and continue within that scope. Once an approach is selected, implement it.
For a requested hybrid, reconcile the actual conflicts and continue once the direction is clear.
UI concepts
Inspect the existing product, supplied references, content, and design system. Keep concepts comparable in functional scope and content while varying meaningful visual or interaction choices.
When visual previews are requested, use an available image or rendering tool, inspect the results, and present each direction with its tradeoffs. If the requested preview cannot be produced, explain the limitation, provide useful concept descriptions, and obtain a decision before substituting a deliverable that changes the requested result.
Treat concept previews as references until production asset use is intended and authorized. Preserve the selected reference when later comparison needs it.
Debugging Workflow
Use evidence to locate the failing boundary and fix the cause while preserving business intent.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Investigate
- Capture the failing command or flow, input, expected behavior, actual result, and relevant environment. Read the error and nearby source before expanding the search.
- Reproduce the smallest useful case when practical. If reproduction is unavailable, distinguish what logs or source prove from what remains a hypothesis.
- Trace the symptom through the affected boundaries. Choose checks that distinguish plausible causes; independent observations can run together when safe. Avoid stacking speculative fixes.
- For a UI failure, inspect the supplied image or rendered state. Annotate a copy only if that makes a material ambiguity easier to resolve.
Read debugging-playbook.md for deeper isolation, flaky failures, or temporary instrumentation. Keep sensitive data out of logs and remove temporary debug code.
Fix and verify
Make the smallest coherent fix, preserving unusual business rules unless evidence shows they are the defect. Avoid unrelated refactors. Add a regression test when it provides durable protection, ideally demonstrating failure before the fix.
Rerun the original failure and affected checks. Complete repository-required checks; broaden only when a remaining risk warrants it and authorization permits. Reuse results that remain valid.
If measurement or test design becomes the main work, consult the relevant specialist guidance directly when available.
Report
Explain the cause, fix, and evidence that the failure is resolved. Include reproduction limits or remaining uncertainty. Record a difficult bug in existing durable docs only when future work would benefit.
Design System Generator
Produce a concise design system grounded in the product's actual stack and visual language. Document decisions that make future UI work consistent.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Inspect before proposing
Read existing design docs, brand references, representative screens, shared components, theme configuration, tokens, and build tooling. Infer framework, CSS approach, themes, browser support, and export formats from those sources. Ask only about unresolved product choices that materially affect the document.
Preserve an established coherent system. For a new product, recommend one suitable direction within the user's constraints; compare alternatives only when useful or requested. Do not add a component library or migrate build tooling merely to match this skill's examples.
Write the project contract
Use TEMPLATE_DESIGN_SYSTEM.md as a menu of topics. Omit inapplicable sections and replace examples with verified project decisions. Cover the relevant:
- surfaces, themes, devices, and language or RTL constraints;
- token ownership, typography, color, spacing, layout, and motion;
- shared components and the interaction states each actually supports;
- extension rules for tokens, components, utilities, and local exceptions;
- keyboard interaction, visible focus, contrast targets, semantic markup, and reduced motion;
- visual verification at comparable states and viewports;
- asset loading and cache invalidation responsibilities when the design system owns them.
Link to existing build or deployment guidance for pipeline details. Hashed filenames and manifests are one cache strategy, not a required new build system. Avoid documenting support for frameworks or themes the product does not use.
Keep statements actionable and project-specific. The document serves the product team; omit prompt-writing advice and generic framework tutorials.
Outputs
Update the existing design-system owner or create DESIGN_SYSTEM.md at the repository's conventional location. Export CSS or JSON tokens only when requested or needed by the agreed implementation. Read examples/tokens.css and examples/design-tokens.json only for those formats; examples/manifest.example.json is relevant only to a manifest-based pipeline.
If discoverability needs an instruction-file link, use the minimal pattern in examples/AGENTS.patch.md, preserving any existing AGENTS.md/CLAUDE.md ownership or symlink. Do not add duplicate instruction files or repeated design rules.
Verify
Check documented paths, token names, component APIs, and build claims against their owners. Inspect representative rendered components when making visual decisions or changing tokens; report when visual validation could not run. Remove placeholders, contradictions, and duplicate sources of truth.
Report the document and any exports, the material decisions, verification performed, and unresolved choices.
Docker Local Development
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Guardrails
- Design for local development. Keep production images, secrets, deployment, certificates, and runtime topology separate.
- Inspect before asking questions or proposing services. Treat detection as evidence, not authority.
- Preserve existing Docker files and unrelated working-tree changes. Keep a semantic diff for material stack changes. Ordinary configuration edits are covered by a setup or repair request; volume deletion, destructive resets, and data migrations need authorization covering those effects.
- Generate only services the project uses or the user explicitly requests. A database is not mandatory when the project uses SQLite, a host service, or an external database.
- Prefer direct foreground commands and one concern per service. Add Supervisor or PM2 only when the project already requires it or production-parity testing justifies it.
- Prefer a stable top-level Compose
name:and role-based service names. Do not setcontainer_nameby default because it prevents service scaling and creates cross-project collisions. - Select images by project constraints, team or production compatibility, trusted publisher, supported version, and architecture. Treat an already-downloaded image only as a tie-breaker. Avoid floating
latesttags in generated files. - Publish only ports needed by the host. Bind local-only ports to
127.0.0.1by default; keep databases, caches, SMTP, PHP-FPM, and internal APIs unexposed when possible. - Keep secrets out of committed files, generated documentation, command output, and frontend or proxy containers. Generate an ignored local env file plus a safe example when configuration is needed.
Workflow
1. Inspect the project
Run project commands from the target project directory. Resolve bundled helpers through <skill-directory>/scripts/; their location is separate from the project working directory. Check Docker and Compose capabilities before selecting syntax:
docker version
docker compose version
Inspect, when present:
compose.yaml,compose.yml,docker-compose*.yml, and override filesDockerfile*,.dockerignore,.devcontainer/, Makefiles, and package scripts- application manifests, lockfiles, runtime-version files, env examples, and monorepo/workspace files
- existing local proxy conventions, Compose project names, networks, volumes, and host port mappings
- Git status and repository instructions before editing tracked files
Use stack detection when it adds useful evidence; direct inspection is enough for a known, narrow repair. Resolve the script from this skill directory:
"<skill-directory>/scripts/detect-stack.sh" "<project-root>"
The script emits JSON on stdout and diagnostics on stderr. Confirm uncertain findings from source files without printing secret values.
When Docker is available, optionally inspect local images and networks:
"<skill-directory>/scripts/detect-images.sh"
"<skill-directory>/scripts/detect-network.sh"
Do not let cached images or a detected network override project compatibility or isolation requirements.
2. Resolve the design
Infer and summarize:
- apps in scope, dev commands, internal ports, shared packages, and live-reload needs
- runtime and package-manager versions from constraints and lockfiles
- database, cache, queue, scheduler, mail, and debugging services actually used
- existing reverse proxy, explicit
.localhosthostnames, same-origin/apirouting, and required host exposure - bind mounts versus Compose Watch; use Watch only when supported by the installed Compose version
- merge versus focused repair versus replacement of existing Docker files
Resolve ordinary setup choices from evidence. Ask only when missing information changes the apps in scope, data compatibility, network exposure, or a material replacement not already requested.
3. Load only relevant references
| Need | Read |
|---|---|
| Detection rules and monorepo discovery | references/tech-stack-detection.md |
| Images, processes, dependencies, mounts, environment, Dockerfiles | references/service-configuration-guide.md |
| WordPress, Drupal, or Joomla | references/cms-configuration-guide.md |
| Ports, proxies, domains, networks, host access | references/networking-ports-guide.md |
| Existing Compose or Dockerfile changes | references/merge-backup-strategy.md |
| Readiness checks and smoke tests | references/health-check-patterns.md |
Use assets as starting points, not immutable output. Remove unselected services and adapt placeholders, healthchecks, commands, paths, users, and versions to the detected project.
4. Preview and generate
For a material change to an existing stack, state what will change — files, services and versions, host ports and domains, mount strategy — as part of doing it.
Generate the smallest coherent setup within the existing authorization. Depending on the project that is a dev Dockerfile or build target, .dockerignore, compose.yaml without the obsolete top-level version, the selected proxy or process configuration, and, when configuration is needed, an env example plus an ignored local env file. Add usage notes only when useful or requested.
Prefer:
- bind-mounted source with named dependency volumes for straightforward active development
- Compose Watch with
sync,sync+restart, orrebuildrules for large trees, native dependencies, or projects that benefit from granular sync - one-shot dependency installers only when they solve a real bind-mount or monorepo problem; mark them as expected to exit successfully
- separate worker and scheduler services using the same image as the app
- Compose profiles for optional debugging and administration tools
- health-gated dependencies only when the dependency defines a valid healthcheck
Run migrations, seeds, CMS installers, destructive cleanup, or database write tests only when authorization covers their data effects. A request to configure containers alone does not imply those actions.
5. Verify
Run static checks first:
docker compose config --quiet
docker build --check .
Use docker build --check only when the installed Docker version supports it. Build and start when the request includes running or verifying the local setup. For file-generation-only requests, keep execution within that narrower scope:
docker compose build
docker compose up -d --wait
docker compose ps -a
If --wait is unavailable, start detached and poll declared healthchecks with a bounded timeout. Inspect logs for failed or restarting services.
Run the bundled checks when applicable:
"<skill-directory>/scripts/health-check.sh"
"<skill-directory>/scripts/db-test.sh" # connection/read-only query
"<skill-directory>/scripts/db-test.sh" --crud # explicit temporary-table CRUD check
Also run a stack-specific smoke check such as php artisan about, wp core version, drush status, python manage.py check, or the application's health endpoint. When runtime verification is in scope, verify hot reload with a harmless temporary edit and restore it afterward. Reuse passing checks unless relevant configuration or runtime conditions change.
6. Report
Report:
- generated or modified files
- selected services, versions, local URLs, and explicit host exposure
- exact verification commands and results
- expected stopped one-shot services
- assumptions, skipped checks, and platform-specific limitations
Never include secret values in the report.
Host Port Registry
Persistent host-port tracking is optional. First check:
PORT_REGISTRY_FILE="${DOCKER_LOCAL_DEV_PORT_REGISTRY:-${XDG_STATE_HOME:-$HOME/.local/state}/docker-local-dev/HOST_PORT_REGISTRY.md}"
test -f "$PORT_REGISTRY_FILE" && sed -n '1,220p' "$PORT_REGISTRY_FILE"
Creating or refreshing a registry scans beyond the current project and records local paths. Establish authorization for the scan root and output path; reuse it if already given. Then run:
node "<skill-directory>/scripts/scan-host-ports.mjs" --root "<approved-root>" --out "$PORT_REGISTRY_FILE" --yes
Treat registered ports as reserved even when no process is currently listening. For a single project without a registry, a live port check is sufficient.
Acceptance Criteria
- Generated Compose configuration parses without unresolved placeholders.
- Selected images and commands match project constraints and contain no unreviewed floating tags.
- App containers reach dependencies by Compose service name, not
localhost. - Optional services are absent or profile-gated.
- Host ports are minimal, conflict-free, and loopback-bound unless broader access was requested.
- Healthchecks invoke commands available in their images and test readiness rather than process presence alone.
- Source changes reload as intended; lockfile changes follow the documented install or rebuild path.
- No secrets, production data, private domains, or unauthorized mutations appear in generated files or reports.
Documentation Guidelines
Capture durable meaning that code alone does not explain: business intent, ownership, invariants, permissions, contracts, and operational decisions. Let source and tests own implementation details and executable evidence.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Find the owner and evidence
Read the relevant documentation index and owner when present, then verify affected facts against source, tests, schemas, configuration, and runtime evidence. Follow links needed to understand the changed contract; stop when further reading no longer affects the result. Missing or stale documentation is a reason to inspect source, not a prerequisite that blocks work.
For the scope at hand, identify applicable actors, triggers, rules, state transitions, inputs/outputs, side effects, failure paths, ownership, and compatibility requirements. Omit irrelevant categories; record unresolved material facts without inventing them.
Change docs when durable meaning changes
| Change | Documentation action |
|---|---|
| Internal refactor, formatting, or fix restoring documented behavior | Update only affected paths or evidence anchors, if any |
| User behavior, business rule, or workflow | Update its existing owner |
| API, schema, permissions, events, or compatibility | Update the contract and affected consumer mappings |
| Setup, migration, deployment, backup, or recovery | Update the owning runbook |
| Entity renamed, moved, or removed | Repair discovery routes and stale references |
| Duplicate or contradictory docs | Preserve valid facts in one owner, repair links, then remove stale copies within scope |
Avoid docs changes that merely record task activity. Keep transient plans, command logs, and CI output in the task, PR, or an existing evidence surface unless they represent a durable operating requirement.
Write for discovery and maintenance
- Give each durable fact a clear owner. Consumers link to it and document only their own mapping or constraints.
- Follow the repository's layout. Add routers, registries, or metadata only when a real discovery or tooling need justifies their upkeep.
- Use concrete rules, stable searchable headings, examples, and a few source/test anchors. Prefer symbols and paths over brittle line numbers.
- Separate facts, recommendations, and unknowns. Remove generic tutorials, speculative requirements, copied implementation, and status metadata that will rot.
- Preserve historical records when they still serve an audit, migration, or operational purpose. Use Git history for superseded tracked content when sufficient.
Read templates.md for the document type, architecture.md for multi-owner structure, or audit-cleanup.md for consolidation.
Verify and report
Trace discovery from the existing entrypoint to the updated owner. Check links, identifiers, commands, evidence anchors, and any affected consumer contracts. Search for contradictory copies and old names. Run focused doc or generation validators plus applicable required gates; application tests are warranted only if the change affects executable behavior or their contract.
Report the durable facts changed, important removals or consolidations, verification, and remaining gaps.
Laravel 11/12 App Guidelines
Work from what the repository actually installs. Laravel 11 and 12 applications vary widely in skeleton, frontend, auth, and command runner, and most mistakes come from assuming a fresh-application default the project does not use.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Detect before deciding
Read repository instructions and the relevant documentation owners, then confirm from composer.json, composer.lock, package.json, frontend lockfiles, bootstrap/app.php, Compose files, and config/:
- the command path: host PHP, Sail, Docker Compose, or a repository wrapper, used consistently;
- API-only or full-stack, and the frontend: Inertia with React, Vue, or Svelte; Livewire; or Blade;
- the auth stack (Fortify, Sanctum, Passport, or custom) and the test runner (Pest or PHPUnit).
For version-sensitive behavior, use Laravel Boost search-docs when Boost is available, since it filters by installed versions; otherwise use the official documentation for the installed major. boost-tools.md covers Boost usage and its data-safety limits.
Follow the repository's architecture, naming, UI language, and component patterns, and keep its dependencies unless the user asks for a change.
Framework specifics that are easy to get wrong
- Skeleton. The modern skeleton configures middleware, exceptions, and routing in
bootstrap/app.php, registers providers inbootstrap/providers.php, and defines closure commands and schedules inroutes/console.php. An application upgraded from Laravel 10 may still useapp/Http/Kernel.phpandapp/Console/Kernel.php; that structure remains supported, so keep it unless the task is to migrate it. - API routes. Fresh applications omit
routes/api.php.install:apicreates it and installs Sanctum, so run it only when both are intended. API-only work should not pull in Vite, Tailwind, or Node. - Column changes.
change()drops every modifier that is not restated. Inspect the current column and repeat the modifiers that must survive. - Destructive database commands.
migrate:fresh,migrate:reset, rollbacks, anddb:wipeneed authorization that covers the target and its data loss; reuse permission already given. - Queries. Bound raw expressions and the query builder are fine where they are clearer than Eloquent; untrusted input is never interpolated into SQL.
- Inertia. Discover the page directory and casing from the page resolver. Use the form and navigation APIs of the installed Inertia major; examples from another major do not transfer.
- Wayfinder, when installed: use named imports so output tree-shakes, and regenerate after route or controller changes.
- Tailwind. Detect v3 or v4 from the lockfile. v4 is configured in CSS (
@import "tailwindcss",@theme) and removes utilities that v3 deprecated; leave a working v3 setup on v3 unless a migration is requested. - Livewire and Blade. Match the installed Livewire major and the component style neighbors use, without introducing a second frontend framework.
Verify
Keep the repository's test runner and confirm generator flags with php artisan help make:test. Run the smallest relevant target (php artisan test <file> or --filter=) plus the checks the repository requires, and add regression coverage where it protects meaningful behavior. Broaden for an affected contract or unresolved risk, within any stated suite budget.
Run the configured formatter on changed code; vendor/bin/pint --dirty fits when Pint is installed.
Report the changed behavior, the checks run and their results, and any material assumption left unresolved.
Laravel 13 App Guidelines
Overview
Use a repository-first workflow for Laravel 13 work. Detect the actual framework, packages, frontend, command runner, and local conventions before selecting a Laravel pattern; do not turn optional Laravel 13 capabilities into dependencies.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Execute the Workflow
- Read repository instructions such as
AGENTS.md,CLAUDE.md, and relevantdocs/files before making decisions. - Inspect
composer.json,composer.lock,package.json, frontend lockfiles,bootstrap/app.php,bootstrap/providers.php, routes, configuration, and tests. Usephp artisan aboutorcomposer showwhen dependencies are installed and the repository's command runner permits it. - Identify the supported command path: host PHP, Sail, Docker Compose, or a repository wrapper. Reuse that path consistently and do not assume Sail.
- Confirm the application shape: API-only or full-stack; Blade, Livewire, or Inertia; frontend framework and major version; authentication; test runner; queue, cache, search, and database drivers.
- Consult version-matched guidance before changing framework behavior. Prefer
Laravel Boost
search-docswhen Boost is installed and available; otherwise use Laravel 13.x or the installed package's official documentation. - Follow existing architecture and naming. Implement the smallest coherent change, add or update focused tests, and run focused checks for the affected surface, plus required repository checks. Broaden only when changed contracts or unresolved risks justify it, within the authorized testing budget.
Do not install, upgrade, or replace packages merely because this skill lists them. Confirm a task requirement and compatibility first.
Apply the Laravel 13 Baseline
- Require PHP 8.3 or newer for Laravel 13 and respect the exact platform range declared by the repository and its deployment environment.
- Configure application routing, middleware, and exception handling through
bootstrap/app.phpwhen the project follows the modern skeleton. Register application providers throughbootstrap/providers.php. - Treat
routes/web.phpandroutes/console.phpas fresh-application defaults.routes/api.phpandroutes/channels.phpare optional and may be installed byinstall:apiandinstall:broadcasting; do not assume they exist. - Preserve an upgraded application's established structure when it remains supported. Do not reorganize it to resemble a fresh Laravel 13 application unless the task requires that migration.
- Use named arguments for Laravel framework methods cautiously because parameter names are outside Laravel's backward-compatibility promise.
Design HTTP and Domain Changes
- Keep controllers and route closures thin. Put reusable domain behavior in the application's existing action, service, job, model, or domain layer instead of introducing a new abstraction by default.
- Use Form Requests for reusable or non-trivial validation and authorization. Inline validation remains reasonable for a small one-off endpoint when it matches local conventions.
- Enforce authorization with policies, gates, or the repository's established authorization layer; validation is not authorization.
- Prefer Eloquent models and relationships for domain-oriented work. Use the query builder or bound raw expressions when they make bulk or complex queries clearer and measurable; never interpolate untrusted SQL.
- Prevent N+1 queries with deliberate eager loading, constrain selected columns
when useful, and use
whenLoadedin API resources. Paginate, cursor, or chunk large result sets according to consistency and memory requirements. - Wrap multi-write invariants in transactions and make queued side effects safe for retries. Dispatch after commit when consumers require committed data.
- When changing a column with
change(), restate every modifier that must be retained because omitted modifiers are dropped. Inspect the current schema first and make migrations reversible when practical. - Require authorization covering the target and data effects of destructive
operations such as
migrate:fresh,db:wipe, broad deletes, and irreversible drops. Reuse permission already given; a code edit alone does not grant it.
Build APIs Deliberately
- Add or use
routes/api.phponly when the project exposes a stateless API. Useinstall:apionly when adding that surface is part of the requested change. - Follow the existing response envelope, error format, pagination, and versioning contract. Use standard API Resources by default when the project uses them.
- Use Laravel 13 JSON:API Resources only when the API contract requires JSON:API; do not silently convert an established API format.
- Detect Sanctum, Passport, session authentication, WorkOS AuthKit, or custom authentication from installed packages and configuration. Preserve its guard and token semantics.
- Keep API-only work independent of Vite, Tailwind, and Node unless those tools are already part of the requested surface.
Follow the Detected Frontend Stack
- Discover page, component, and layout paths from the repository; casing and
locations vary. Do not assume
resources/js/Pages. - For Inertia, use the APIs supported by the installed Inertia major version. Official Laravel 13 starter kits use Inertia 3 for React, Vue, and Svelte, but existing Laravel 13 apps may use another compatible version.
- Use Inertia links, forms, visits, partial reloads, deferred data, and SSR only where the installed adapter and local patterns support them. Provide loading, empty, validation, and error states for affected interactions.
- Use Wayfinder only when installed. Prefer generated named imports where the project supports them and run the repository's route-generation or build command after route changes.
- For Livewire, follow the installed Livewire version and component style. Use Flux UI only when present; do not replace Blade or existing components merely to match a starter kit.
- For Tailwind CSS 4, preserve the project's CSS-first configuration, tokens, component library, responsive rules, and dark-mode strategy. Do not migrate a working Tailwind 3 setup unless requested.
- Read
references/stack-guidance.mdwhen the task touches starter kits, authentication, Inertia, Livewire, Blade, Wayfinder, or Tailwind.
Adopt Laravel 13 Features Only When They Fit
Laravel 13 adds first-party AI primitives, JSON:API resources, semantic and
vector search, and stronger request-forgery defaults. Treat each as an optional
design choice with package, provider, database, security, cost, and operational
consequences. Read references/laravel-13-features-and-upgrade.md before using a
new Laravel 13 feature or upgrading an application from Laravel 12.
Test, Format, and Verify
- Preserve Pest or PHPUnit according to the repository. Laravel 13 supports both; do not force PHPUnit into a Pest project or vice versa.
- Prefer feature tests for behavior crossing framework boundaries and focused unit tests for isolated logic. Add regression tests when they provide durable protection.
- Confirm generator flags with
php artisan help make:testbefore using them. For upgrades, expect Pest 4 or PHPUnit 12 only after dependency compatibility has been verified. - Run the smallest relevant test target. Use the repository wrapper and test database; never point tests at production.
- Run focused formatting, static analysis, frontend lint, type-check, build, and browser or E2E checks when they can fail for the changed surface. Complete required checks and reuse passing results unless relevant changes invalidate them. Follow explicit approval requirements for broader suites.
- Report the exact checks run, results, and any checks that could not run.
Use Laravel Boost Safely
- Read application information before relying on framework or package versions.
- Use
search-docswith short topic queries before implementing version-sensitive behavior. Let Boost filter documentation by installed package versions. - Discover the tools exposed by the installed Boost server instead of assuming every Boost release has the same names or capabilities.
- Keep database inspection read-only and scope executable-code tools to local or test environments. Never use Tinker or database tools to mutate production data without explicit authorization.
- Read
references/boost-tools.mdfor the current tool-selection and fallback workflow.
Preserve Project Integrity
- Reuse existing dependencies, components, factories, policies, resources, and conventions before creating replacements.
- Keep credentials in environment configuration and never expose secrets in logs, fixtures, frontend bundles, or agent output.
- Update durable documentation when behavior, setup, public APIs, or operational procedures change.
- Distinguish framework facts from recommendations and from repository-specific conventions in the final handoff.
Office Web UI System
Create a clear operational interface that supports scanning, filtering, comparing, editing, and managing records. Preserve usable space and the product's visual identity.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Establish the page's job
Inspect the framework, component library, design-system sources, tokens, shared shell, and representative screens. Infer whether the work is an operational surface from the request and project; ask only if that distinction remains unclear and would change the design.
Identify the primary task and dominant region. Use dashboard/report, CRUD/list, workspace/detail, and form/wizard as composition guides. Read page-type-playbook.md for an unfamiliar page type.
For screenshot-driven work, establish what should match and what should adapt to the existing product. A supplied target is the selected direction.
Compose for real work
- Make title, context, primary action, filters, and data hierarchy clear. Preserve table and form width before adding supporting panels.
- Keep dense CRUD surfaces restrained. Use expressive summary or hero treatments only when they help users understand the page.
- Group metrics by their meaning and define date ranges, units, comparisons, and drilldowns where relevant. Avoid decorative statistics without a user task.
- Reuse shared components, tokens, utilities, and motion rules. Add local exceptions only for a concrete visual or behavior gap.
- Support relevant loading, empty, error, validation, selection, disabled, and focus states. Preserve keyboard access, touch usability, and readability in supported themes and viewports.
- Adapt primitives to the installed framework and library; do not force a new shell, pill topbar, glass style, or dark theme onto a coherent existing product.
Consult visual-language.md, navigation-and-panels.md, and component-recipes.md for the component being designed. Use framework-adaptation.md for library internals or scoped-style issues.
Keep regions discoverable
Use semantic markup, accessible names, existing component boundaries, or stable project locators to identify important regions. Add readable semantic classes when they solve a real discovery problem; do not normalize unrelated markup just to satisfy a class scheme.
Read locator-class-contract.md when adding such classes. The optional scanner maps those classes to files:
python3 "<skill-directory>/scripts/scan_ui_locators.py" "<project-root>" --match layout-sidebar
Use direct source search when it already identifies the target. The scanner does not validate accessibility or replace browser inspection.
Verify the result
Follow the host's browser policy and inspect the actual rendered page. Capture the region or page that demonstrates the change; use equivalent viewport, theme, account, and data for before/after or reference comparison. Annotate ambiguous images only when that helps resolve a consequential question.
Check hierarchy, density, overflow, text fit, table interactions, keyboard-visible focus, and supported themes/responsive states. Inspect the real rendered library nodes when overrides affect dark mode. Fix material differences from the selected target or report the limitation when rendering is unavailable.
Run focused project checks and relevant regression coverage. Report the user-visible change, evidence, browser surface, and remaining gaps; keep manual screenshots distinct from automated E2E coverage.
Performance Optimization
Make a performance claim that survives scrutiny: a confirmed bottleneck, a change that addresses it, and a before/after comparison under the same conditions, with business behavior unchanged.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Define the claim and its envelope
Establish what is slow, where, for whom, and compared to what, then capture a baseline before changing anything: timing, query count, payload, memory, CPU, bundle size, Web Vitals, a profile, or logs.
Results are comparable only inside a fixed benchmark envelope, so record it: workload and data size, starting state, warm or cold cache, account and permissions, command and flags, worker count, retries, resource limits, and concurrent activity on the host. For noisy measurements, repeat enough to report a representative value and its spread; the best run is not the result.
Infrastructure health is part of the measurement. A run with crashes, OOM kills, unexpected restarts, failed setup or cleanup, or orphan processes is rejected and noted, not averaged in.
An unexplained correctness failure comes first: isolate it before optimizing, because a faster wrong answer is not an improvement.
Find the bottleneck
Attribute the time before choosing a fix. Separate backend, database, network, frontend rendering, asset loading, build tooling, and external dependencies; within a test or benchmark run, separate setup, exercise, and cleanup.
Measure the work a flow produces instead of inferring it from where the driver runs. A browser or test runner on the host can still drive memory, CPU, and database load inside services, and a few visible actions can amplify into many requests, statements, rows, jobs, and retries.
Use existing instrumentation, traces, query logs, and profilers, and read the rules that govern the measured path before changing its data flow. performance-playbook.md has domain checks for databases, backends, frontends, assets, builds, tests, and caching.
Fix the confirmed cause
Start with the smallest change that addresses the measured bottleneck, and reach for new dependencies, infrastructure, or architecture only when measurement shows the local fix is insufficient.
- A cache is a contract. Define its invalidation, freshness, and per-user or per-tenant boundaries before relying on it.
- A faster suite must still test the same thing. Keep authentication, authorization, realtime, and other behavior under test intact.
- When concurrency exposes a failure, reproduce and fix the focused case. Raising timeouts or retries hides races and failed requests.
- A tradeoff in correctness, freshness, accessibility, or UX that the user has not accepted is theirs to decide.
Verify
Rerun the same measurement inside the same envelope and compare. Where the workflow mutates state, confirm service health, cleanup, state restoration, and process termination on success, failure, and handled interruption.
Complete required checks and reuse focused evidence that is still valid. Broaden measurements or tests when the claim or an unresolved regression risk needs it, within the agreed budget. Add a regression guard when it would catch the bottleneck returning.
Report
Give the baseline and after measurements with the envelope, sample size, and any rejected runs; the bottleneck and the change; how the result was verified; and the tradeoffs, cache invalidation rules, and risks that remain.
Project Development Mindset
Deliver the requested outcome using project evidence and the smallest coherent change. Scale investigation and verification to impact, uncertainty, and reversibility.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Establish the task
- Inspect applicable instructions, Git state, and the source, tests, configuration, and docs relevant to the request. Preserve unrelated user work and follow the repository's branch and freshness policy.
- Identify observable success criteria and affected contracts. Plan in proportion to dependencies and uncertainty.
- Distinguish intended behavior from current behavior. Resolve stale or conflicting docs against source and runtime evidence; ask only when the remaining choice belongs to the user.
- Keep the original objective and accepted changes in view during long work. A status question or correction usually steers the task rather than replacing it.
Implement
- Reuse project components, dependencies, commands, and architecture when their semantics fit. Change a harmful pattern only where it affects this task.
- Keep abstractions tied to current invariants or meaningful reuse. Avoid speculative options, new frameworks, and adjacent cleanup without a present need.
- Inspect affected callers and consumers when changing public APIs, persisted data, permissions, or cross-project contracts.
- Use installed versions and official documentation for uncertain external APIs. Keep credentials out of source, logs, fixtures, and output.
- Carry authorized work through to completion. Prepare a concrete, reviewable result before requesting any still-missing approval for publication, deployment, or other consequential actions. Do not infer those actions from an ordinary implementation request.
Verify and review
- Choose checks that can detect failures in the changed behavior, using the project's existing tools. Complete required checks and follow any explicit testing budget.
- Add regression coverage when it protects meaningful behavior. Skip tests that merely duplicate a reversible, low-impact edit.
- Reuse passing evidence for unchanged code and equivalent environments. Expand or repeat checks for new changes, failures, affected contracts, or unresolved risks; stop once the evidence is sufficient. Offer a broader suite only when it would resolve a concrete gap, respecting repository approval requirements.
- For material UI changes, inspect the rendered result at relevant states and viewports under the host's browser policy. Distinguish manual browser evidence from automated E2E tests.
- Review the complete task diff against the intended base for missing requirements, regressions, unsafe changes, and accidental files. Fix actionable findings and rerun affected checks.
- Update durable documentation when behavior, setup, commands, ownership, or contracts change. Use existing owners instead of creating new documentation structures for routine work.
Use specialist guidance selectively
Routine tests, docs edits, framework commands, and browser checks stay part of implementation. Bring in a specialist skill when its domain is the main difficulty of the current step.
Read quality-skill-routing.md when choosing a specialist would help, or ui-ux-concept-routing.md for visual decisions and reference matching. Load only relevant guidance, avoid running two workflows for the same responsibility, and let go of a phase's instructions once the task moves on. An unavailable optional skill should not block work the current tools can complete.
run-reviewable-subtask-loop is the user's to invoke; task size and internal subtasks neither activate it nor authorize subagents.
Handoff
Lead with what changed and why. Report relevant checks and their results, remaining gaps, and any decision still needed. Compare the delivered behavior with the user's criteria; fix in-scope gaps before stopping. Describe remaining uncertainty through the evidence behind it.
Run Reviewable Subtask Loop
Deliver coherent, recoverable increments and review the aggregate result before publication.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Establish the series
Inspect repository instructions, working-tree and worktree state, the intended base and its fetched remote counterpart, and relevant delivery checks. Follow repository freshness policy; preserve the intended base and user changes. Do not silently merge, rebase, reset, or overwrite work to make the starting state convenient.
Resolve the branch, commit, push, PR, merge, and cleanup permissions from the user's request. A request to implement does not automatically authorize publication or final merge. Ask only about missing permissions when needed, after completing independent preparatory work.
Use one integration branch and sequential commits by default. Use temporary subtask branches when repository policy or an actual isolation/recovery need justifies them. Never check out the same branch in two worktrees. Record initial base and integration SHAs and the exact branches created by this series.
Inspect remote triggers before publication. Read remote-ci.md when push, PR, or merge can start CI. Honor explicit local-only, cost, and separate-approval requirements.
Keep a compact ledger
Use the conversation or an existing project progress surface. Persist a plan only when requested or needed for recovery across sessions; use the repository's established location. Record exact task-owned artifact paths and preserve them according to the user's retention preference.
For each subtask, track its responsibility, acceptance criteria, dependencies, focused checks, status, and resulting commit. Add findings, evidence, and recovery points as they exist.
Split at boundaries that have distinct review, test, rollout, or recovery value. Keep source and generated output together. Combine mechanical fragments; separate unrelated contracts or risky migrations. Adjust implementation details within the agreed outcome, and ask before materially changing an approved scope.
Execute each subtask
- Start from the verified integration tip, using an isolated branch only when warranted.
- Implement the complete responsibility with needed tests, documentation, and generated artifacts.
- Run checks for that responsibility and affected shared contracts. Do not run the aggregate suite for every commit.
- Review the complete subtask diff. Fix actionable issues and rerun affected checks; revisit the wider review only when the fix changes its assumptions.
- Commit when the required checks pass. If using a subtask branch, integrate by the repository-approved method, preferring fast-forward when possible.
- Record the commit, review outcome, checks, and last-known-good tip. Recheck integration only when it changes the tested behavior or conditions.
Keep dependent work behind unresolved failures. For invalidated work, read recovery.md and preserve a recovery point before any authorized history change. Temporary branch cleanup follows branch-cleanup.md.
Verify the complete result
Review the complete diff against the intended base and map it to the user's criteria. Fetch the base again before delivery. If it advanced, assess the integration risk and follow repository policy; obtain direction before an unapproved merge or history rewrite.
Run the smallest aggregate checks that cover the changed responsibilities and their contracts, plus required release or repository gates. Reuse valid subtask evidence. Respect explicit suite budgets; propose broader tests only for a concrete gap.
For material visual work, inspect relevant rendered states and viewports and compare any selected reference. Check in the browser as early as it helps expose design or integration errors. Follow the host browser policy and distinguish manual Browser evidence from source-controlled E2E tests.
Record the final commit/tree and the inputs or environment on which checks depended. Changes invalidate affected evidence, not every unrelated check. Revalidate changed contracts after conflict resolution; a documentation-only progress update does not by itself invalidate runtime tests. Provider-required checks may still need the current PR SHA.
Publish and clean up
Use the authorized aggregate path: one PR, or commit and push if that is what the user requested. Keep intermediate branches local unless remote backup or collaboration is requested. Report the result, meaningful review fixes, checks, and gaps in plain language.
Merge only when requested, repository-required checks pass on the candidate, and no unresolved finding makes the merge unsafe. Verify the resulting commit/tree, including any base changes. An existing passing check does not need a local rerun merely because the next step is squash merge.
Clean up only the exact task-owned branches and temporary files covered by authorization. Keep evidence needed for pending review or recovery; do not delete plan documents the user wants retained. Follow branch-cleanup.md, including its squash-merge checks. Preserve unrelated branches and worktrees.
Resume or report a blocker
Reconcile the ledger with actual Git state, review status, and verification evidence. Resume from the first incomplete step, keeping completed work. If ownership, authorization, base freshness, protected-branch checks, or an unresolved scope decision prevents safe progress, explain the precise blocker and continue any independent work that remains possible.
Testing Verification
Verify observable behavior at the narrowest reliable level, using project conventions and the failure cost to choose coverage.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Select evidence
Inspect relevant contracts, nearby tests, fixtures, commands, and CI definitions. Choose checks that can fail for the behavior in question, including important negative paths. Use test-strategy.md when the test level or coverage tradeoff is unclear.
Prefer existing test infrastructure and stable fixtures. Test public behavior rather than incidental implementation details; avoid hidden network dependencies, production data, and timing-based assertions. Add automation when it protects meaningful behavior, without writing tests that simply mirror trivial edits.
Browser work
Use the browser surface the host and project policy designate for interactive, exploratory, screenshot, and visual comparison work. If that surface fails, troubleshoot it before falling back to another, and say which surface produced the evidence. When the user named a specific surface, get their direction before substituting a different one.
Source-controlled Playwright E2E provides repeatable regression coverage. Keep it distinct from a manual Browser pass. Read ui-visual-verification.md when comparison conditions or visual ambiguity matter.
Run and finish
Run focused checks and required repository gates. Investigate failures before broadening, and rerun only affected checks after a fix. Reuse passing results for unchanged responsibilities and equivalent conditions. A commit, PR, merge, or handoff alone does not justify repeating a suite.
Follow explicit testing budgets. Propose a broader suite only when it could resolve a material gap; ask when project policy or unapproved cost requires it. Finish once the evidence is sufficient.
Report commands, results, relevant coverage, any browser surface used, and remaining gaps. Do not claim behavioral or visual verification from static checks alone.
UI/UX Concept Implementation
Overview
Turn a selected visual direction into working UI while preserving the project's product identity and producing browser evidence against the target.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Establish The Visual Contract
- Confirm that one direction is selected. A single user-supplied mockup, screenshot, or reference site is a selected target. If materially different concepts remain unselected, obtain the user's selection unless they already authorized choosing an approach.
- If the selected target is an operational dashboard and a dashboard-specific workflow better fits the task, use that guidance directly. Otherwise continue with this general visual-reference workflow.
- Inspect the target and the current rendered UI at the relevant routes, viewports, themes, data states, and interaction states. Ask a narrow question only when unresolved ambiguity would produce materially different results.
- Classify the target's visible decisions as exact (must match), adaptable (translate into the product's visual language), or unspecified (follow established project conventions). Record only the distinctions needed to guide implementation and verification.
- Treat existing project instructions, design-system sources, components, tokens, content, assets, responsive conventions, and accessibility patterns as constraints. Do not replace suitable project identity merely because the reference uses a different system.
- Preserve the selected concept outside committed source only when later comparison genuinely needs a durable artifact. Prefer an existing ignored or environment-managed location; do not create project files or modify ignore configuration solely for transient persistence without authorization.
Implement The Direction
- Map the visual contract to project-owned routes, components, styles, tokens, assets, and representative content. Reuse existing surfaces when their semantics fit; introduce new ones only for a concrete gap.
- Recreate the target's structure, hierarchy, rhythm, responsive intent, and interactions without copying proprietary source, private assets, tracking code, or brand-identifying content that the user is not authorized to use.
- Preserve product behavior and accessible semantics while adapting visual details. Cover only the loading, empty, error, validation, focus, or other states that the affected surface can meaningfully enter.
- Add a dependency only when project tools cannot reasonably satisfy a material part of the visual contract and the tradeoff is clear.
Compare In A Real Rendering Environment
- Follow the host and project browser-testing policy instead of assuming one universal tool. Capture the smallest useful region, using full-page images only when composition, scrolling, or surrounding context matters.
- Compare the target, before state, and updated state at equivalent viewports, theme, data, account, and interaction state when practical. Disclose any mismatch in comparison conditions.
- Iterate on material differences in layout, hierarchy, spacing, typography, color, imagery, overflow, text fit, and interaction. Stop when the visual contract is satisfied or when a concrete blocker requires user direction.
- Verify relevant responsive behavior, keyboard-visible focus, and interaction states. Keep exploratory browser evidence distinct from source-controlled automated E2E coverage.
- If no real rendering environment is available, perform the closest useful source-level check, report the gap, and do not claim visual fidelity.
Final Handoff
Report:
- The selected target and any important exact-versus-adaptable decisions.
- Files changed.
- Browser verification performed, including evidence paths when available.
- Remaining visual mismatches, unverified states or viewports, and comparison limitations.
- The location and uncommitted status of any temporary concept artifact, only when one was actually created.
VPS Docker Traefik Deploy
Deliver the requested deployment work using the project's operating contract. Distinguish planning and file preparation from changing a live environment.
Delegation
Run in the main conversation by default. Delegation can increase usage: obtain explicit approval for the proposed agent count and scope before using subagents. Reuse that approval within its bounds; ask again before expanding the approved count or scope.
Establish the target
Read existing runbooks, Compose and Traefik configuration, release scripts, and available host evidence. Establish the target host, OS, domains, ingress, registry, persistent data, backup/restore expectations, and deployment authorization. Discover facts before asking; for a routine release the existing runbook and configuration usually answer them.
For an existing deployment, preserve supported topology and required release gates. For a new one, prefer a supported Ubuntu LTS or Debian stable host, an operator account with appropriate privileges, registry-built immutable images, and Traefik ingress. Verify current official installation guidance when provisioning; reference commands are examples, not a reason to reinstall a working host.
Keep production boundaries explicit
- Use authorization already granted for the named environment and action. Prepare configuration, diffs, checks, and rollback before asking for any missing live-operation approval. Ask about a new destructive migration or exposure outside that scope.
- Keep databases, caches, registry/admin dashboards, and internal app ports private by default. Expose only needed ingress and operator access, commonly SSH, HTTP/ACME, and HTTPS. Use loopback bindings and SSH tunnels for private operator tools when suitable.
- Keep credentials out of images, source, logs, and reports. Preserve persistent state outside container writable layers.
- Use immutable image tags or digests and retain the prior release. Avoid server-side rebuilds and mutable
latestreferences for releases unless the established operating contract provides equivalent reproducibility. - Address backup and rollback for affected persistent state. A container rollback cannot undo an incompatible database migration; establish the recovery path before applying it.
Prepare, deploy, verify
Choose only the references needed for the work:
| Work | Reference |
|---|---|
| New host, operator access, SSH/firewall, Docker | server-baseline.md |
| Traefik, TLS, DNS, dashboard access | traefik-dns.md |
| Registries, persistence, capacity, backup and restore | registry-storage-backup.md |
| Rollout, health, rollback, maintenance | deploy-checklist.md |
Validate the effective configuration without exposing secrets, confirm image availability and recovery readiness, then execute the authorized rollout. Verify container health, public routes/TLS, logs, and affected application flows. Test restore in an isolated target when required; never restore over live data as a casual verification step.
Reuse valid evidence for unchanged responsibilities, while completing the project's production release gate. Pruning, retention changes, DNS changes, and host hardening belong in a release only when needed and authorized.
Handoff
Report what was prepared or deployed, the target and immutable release identifier, checks and results, and rollback readiness. For new infrastructure, include topology, public exposure, state ownership, and recovery commands. Keep a routine release report to what changed. Say a restore was tested only when it actually ran, not when its configuration was inspected.
Sponsors
Details
- Marketplace
- thienanblog/awesome-ai-agent-skills
- Category
- Community