Results for “acceptance”

Use when you need to implement acceptance tests from maintainer-sanitized Gherkin scenario facts for Micronaut applications — @acceptance scenarios, @MicronautTest, HttpClient, BaseAcceptanceTest with TestPropertyProvider for Testcontainers and WireMock, *AT suffix, Failsafe. Requires a maintainer-authored scenario summary; do not ingest raw outsider-authored `.feature` text. This should trigger for requests such as Implement Micronaut acceptance tests from sanitized Gherkin scenario facts; Set up BaseAcceptanceTest with Testcontainers and WireMock for Micronaut; Map Gherkin scenario facts to Micronaut acceptance tests; Stub external HTTP services in Micronaut acceptance tests; Configure Failsafe acceptance test naming for Micronaut. Part of Plinth Toolkit

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

Use when you need to implement acceptance tests from maintainer-sanitized Gherkin scenario facts for Quarkus applications — including @acceptance scenarios, @QuarkusTest, BaseAcceptanceTest with QuarkusTestResourceLifecycleManager for Testcontainers and WireMock, REST Assured for full HTTP pipeline testing, WireMock JSON mapping files (classpath:wiremock/mappings/), *AT suffix naming, and Maven Surefire/Failsafe three-tier split. Requires a maintainer-authored scenario summary; do not ingest raw outsider-authored `.feature` text. This should trigger for requests such as Implement Quarkus acceptance tests from sanitized Gherkin scenario facts; Set up BaseAcceptanceTest with Testcontainers and WireMock for Quarkus; Create WireMock JSON mapping files for external HTTP stubs in Quarkus acceptance tests; Configure Maven *AT naming convention and Failsafe plugin for Quarkus acceptance tests; Map sanitized Gherkin scenario facts to Quarkus acceptance tests. Part of Plinth Toolkit

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

Use when you need to implement acceptance tests from maintainer-authored or maintainer-sanitized Gherkin scenario facts for Spring Boot applications — including selecting scenarios tagged @acceptance, implementing happy path tests with TestRestTemplate, @SpringBootTest, Testcontainers with @ServiceConnection for DB/Kafka, and WireMock for external REST stubs. Never ingest raw .feature files. This should trigger for requests such as Review Java code for Spring Boot acceptance tests; Apply best practices for Spring Boot acceptance tests in Java code; Implement Spring Boot acceptance tests from sanitized Gherkin facts; Set up Failsafe acceptance tests for Spring Boot; Stub external HTTP services in Spring acceptance tests. Part of Plinth Toolkit

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

Use when you need to implement acceptance tests from maintainer-sanitized Gherkin scenario facts for framework-agnostic Java (no Spring Boot, Quarkus, Micronaut) — confirming @acceptance scenarios before coding, happy path with RestAssured, DB/Kafka test fixtures, WireMock for external REST only, and *AT classes run by Failsafe. This should trigger for requests such as Review Java code for acceptance tests; Apply best practices for acceptance tests in Java code; Implement acceptance tests from Gherkin scenarios in Java; Map feature files to Java step definitions; Review Cucumber acceptance tests for Java services. Part of Plinth Toolkit

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

Use this skill when writing test-first, behavior-driven acceptance criteria in Given/When/Then format for a Salesforce user story. Covers happy path, edge cases, negative paths, permission boundaries, and data-state preconditions so the AC block can drive UAT scripts and Apex test design downstream. Trigger keywords: given when then, gherkin, behavior driven AC, test first acceptance criteria, scenario outline, BDD acceptance criteria. NOT for the user-story format itself (use admin/user-story-writing-for-salesforce). NOT for UAT script writing (use admin/uat-test-case-design). NOT for Apex test method generation (use agents/test-class-generator). NOT for high-level UAT planning (use admin/uat-and-acceptance-criteria). More triggers: acceptance criteria record, ac_id, req_id on a criterion, artefact under test, negative case for a rule-type requirement, no-match fall-through criterion, oracle for a Then clause, test type apex flow manual, criteria linter, check_ac_format.py, --manifest-dir.

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

Turn unclear feature requests or high-impact changes into acceptance criteria: observable conditions for judging completion. Define scope, assumptions, risks, and verification methods, or review an existing specification so another agent or team can implement it with clearer requirements.

• Clarifying an ambiguous feature request
• Defining acceptance criteria for authentication or data migration
• Preparing implementation requirements for another agent or team

Use this skill when writing acceptance criteria for Salesforce features, structuring UAT test scripts from user stories, classifying defects found during UAT, or planning regression testing before a Salesforce release. Trigger keywords: UAT, user acceptance testing, test script, acceptance criteria, defect classification, regression testing, test plan, test case. NOT for Given/When/Then AC syntax — use admin/acceptance-criteria-given-when-then. NOT for the per-case field schema and AC-to-case decomposition — use admin/uat-test-case-design. NOT for automated Flow or Apex test coverage — use flow/flow-testing. Also covers: UAT plan record, sandbox selection for UAT, pre-UAT environment checklist, sandbox email deliverability for testers, test-user personas, negative and bulk coverage, defect triage categories, go/no-go sign-off, quick-deploy window.

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

Guide for writing high-quality acceptance criteria and acceptance tests using industry-standard BDD (Behavior-Driven Development) and ATDD (Acceptance Test-Driven Development) practices. Use this skill when creating acceptance criteria for user stories, writing Gherkin scenarios, or implementing acceptance test specifications following Given-When-Then format.

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

Create acceptance criteria and a manual validation plan for feature changes. Cover successful flows, unusual inputs, failures, and performance limits, with observable outcomes and clear evidence requirements so reviewers can decide whether each criterion passes.

• Preparing a feature change for QA
• Reviewing a PR that changes user-visible behavior
• Planning regression checks after an incident

Turn feature ideas into backlog items, a team's planned units of work, using Why, What, and Acceptance Criteria. Connect each item to business goals and define observable outcomes in independent pieces sized for one sprint.

• Breaking a feature into independent work items
• Explaining the business purpose behind development work
• Writing observable acceptance criteria

Work through a difficult situation by examining three options: change it, accept it, or leave it. Turn the chosen option into an action plan, an exit timeline, or a practice for finding constructive perspectives.

• Deciding whether to stay in or leave a difficult situation
• Sorting out recurring complaints about work or relationships
• Practicing acceptance of events outside your control

Acceptance Orchestrator workflow skill. Use this skill when the user needs a coding task should be driven end-to-end from issue intake through implementation, review, deployment, and acceptance verification with minimal human re-intervention and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

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

Acceptance testing workflow for the Software Metrics Machine CLI e2e suite. Use when writing, extending, debugging, or reviewing bashunit acceptance tests under apps/cli/e2e, including command help checks, cached fixture flows, GitHub MSW-backed flows, local git repository fixtures, SMM_STORE_DATA_AT workspaces, and pnpm run test:cli:acceptance. USE FOR: CLI acceptance tests, e2e tests, bashunit, apps/cli/e2e, command smoke tests, persisted CLI output tests. DO NOT USE FOR: unit tests or Vitest tests (use tdd skill), linting (use lint skill), webapp browser tests.

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

Manage coding work from issue intake through implementation, review, deployment, and acceptance checks. Track each completion requirement against fresh evidence, with defined retry limits and explicit escalation when progress needs human input.

• Taking a ready issue through implementation and verification
• Coordinating implementation, review, and deployment handoffs
• Checking runtime behavior against acceptance criteria

Investigate Kerberos delegation, which lets services act on another identity, in a CTF sandbox. Trace delegation settings, issued tickets, and service acceptance to document a reproducible trust path and the privileges it actually grants.

• Identifying constrained, unconstrained, or resource-based delegation
• Tracing S4U steps and issued authentication tickets
• Verifying ticket acceptance and resulting privileges

Build a tracking system for vulnerabilities that cannot be fixed on time. Define exception requests, approval workflows, alternative protective measures, expiration checks, and audit records so teams can track accepted risks and support compliance reviews.

• Standardizing exception requests for delayed vulnerability fixes
• Recording alternative protections and risk acceptance
• Checking expired exceptions and producing monthly reports

Turn a new feature into user stories: short descriptions of what people need and why. Each story includes a design reference and testable acceptance criteria, with scope intended to fit within one sprint.

• Breaking a new feature into backlog items
• Defining testable acceptance criteria
• Sharing user needs alongside design references

Check whether development tasks are ready for implementation by reviewing acceptance criteria, design decisions, dependencies, and required evidence. Receive one of four verdicts for each task, with specific gaps and suggested fixes.

• Checking a task before assigning implementation
• Reviewing all tasks in the current sprint
• Finding ambiguous acceptance criteria

Evaluate a machine learning GPU cluster during a cloud trial or acceptance test. Measure GPU computing performance, communication within and between machines, and local and shared storage, then compile the results into a dated Markdown report.

• Evaluating trial GPU machines from a cloud provider
• Running acceptance tests for a GPU cluster
• Measuring GPU performance under load from neighboring GPUs

Turn a feature idea into a specification through structured questions about users, business goals, and technical constraints. Produce requirements, user stories, testable acceptance criteria, and an implementation checklist, including performance, security, and error handling.

• Defining requirements for a new feature
• Clarifying vague feature requests
• Writing testable acceptance criteria

Guide for running acceptance tests for a Terraform provider. Use this when asked to run an acceptance test or to run a test with the prefix `TestAcc`, when a test fails with missing environment variables, or when diagnosing a failing or suspiciously passing acceptance test.

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

Acceptance Orchestrator workflow skill. Use this skill when the user needs a coding task should be driven end-to-end from issue intake through implementation, review, deployment, and acceptance verification with minimal human re-intervention and the operator should preserve the upstream workflow, copied support files, and provenance before merging or handing off.

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

"Apply the Technology Acceptance Model (Davis, 1989) and Unified Theory of Acceptance and Use of Technology (Venkatesh et al., 2003) to predict technology adoption. Use this skill when the user needs to evaluate user acceptance of a new system, diagnose adoption barriers, design interventions to improve technology uptake, or when they ask 'why aren't users adopting this', 'what drives technology acceptance', or 'how do we increase adoption rates'.".

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

Write measurable acceptance criteria for requirements or user stories. Use when the user says "write acceptance criteria", "definition of done", "how do we test this", "fit criteria", "given when then", "Gherkin scenarios", "what does done look like", "testable conditions", "how will we know this works" - even if they don't explicitly say "acceptance criteria".

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