Smoke Check

Smoke Check:

Automated Critical Path Testing Before QA

What Is This

The "Smoke Check" skill for the Happycapy Skills platform is a robust, automated gatekeeper designed to ensure software builds meet critical functional standards before formal quality assurance (QA) begins. By running a targeted suite of automated tests, the skill verifies that the core paths and key features are intact and operational, preventing broken or incomplete builds from reaching the QA team. Smoke Check is invoked at the conclusion of a development sprint or after a batch of feature stories have been marked as implemented.

This skill supports a straightforward command-line interface, offering selectable modes (such as sprint or quick checks) and platform-specific validations for PC, console, and mobile deployments. The output is a clear PASS/FAIL report, written to a timestamped markdown file under the production/qa/ directory, documenting the readiness of the build for QA hand-off.

Why Use It

Running untested or partially broken builds through QA is one of the most frequent sources of wasted time and morale loss in software teams. QA professionals rely on receiving builds that have at least passed a minimal set of critical, automated verifications. Smoke Check automates this gating process, enforcing a strict rule: if the build fails the smoke check, it does not proceed to QA.

Key benefits of using Smoke Check:

• Prevents Waste: Ensures QA resources are spent on validating features, not reporting obvious breakages.
• Automated Coverage: Quickly identifies if any critical paths or core features are broken or missing.
• Consistency: Standardizes the definition of "ready for QA," reducing ambiguity and misunderstandings among team members.
• Traceability: Each smoke check produces a documented report, aiding in audit trails and release management.

How to Use It

Smoke Check is invoked via a clear command structure, allowing for flexible execution depending on the phase of development and target platform.

Basic Command Syntax:

/smoke-check [sprint|quick] [--platform pc|console|mobile|all]

Command Arguments

• Base Mode (required, default: sprint):

  • sprint: Runs the full smoke test suite against all stories and features included in the current sprint. This includes a coverage scan and all batch verifications.
  • quick: Runs a faster version of the smoke check, skipping the coverage scan and certain batch tests. Intended for rapid re-checks after minor fixes.

• Platform Flag (optional):

  • --platform pc: Adds PC-specific checks, such as keyboard and mouse input handling, windowed/fullscreen transitions, and desktop conventions.
  • --platform console: Adds console-specific requirements, including gamepad input, TV safe area validation, and platform certification checks.
  • --platform mobile: Targets mobile-specific validations, such as touchscreen gestures, device orientation, and mobile input paradigms.
  • --platform all: Runs platform-specific checks for all supported targets.

Example Commands:

• Full smoke check for console:

  plaintext

  /smoke-check sprint --platform console

• Quick re-check for mobile:

  plaintext

  /smoke-check quick --platform mobile

Output:

After execution, the skill generates a report file:

production/qa/smoke-[YYYY-MM-DD].md

This file contains a summary of the test results, highlighting pass or fail status, key findings, and any coverage gaps detected.

Skill Execution Flow

Smoke Check follows these phases:

1. Automated Test Suite Execution: Runs all relevant automated tests for the selected mode and platform.
2. Critical Path Verification: Ensures that the main user flows and essential functionality are operational.
3. Test Coverage Scan (sprint mode only): Evaluates whether there are gaps in test coverage, particularly for the new or modified stories.
4. Batch Verification with Developer: Optionally prompts the developer for confirmation or additional checks.
5. Report Generation: Summarizes results in a markdown file for traceability.

When to Use It

Smoke Check should be run at key transition points in your development workflow:

• After Sprint Implementation: Once all stories for a sprint are marked as implemented but before assigning the build to QA.
• Before Manual QA Testing: Every time a new candidate build is created for QA to ensure baseline stability.
• After Critical Fixes: Use the quick mode to verify hotfixes or last-minute changes before a release candidate is finalized.
• For Platform-Specific Releases: Whenever a build is targeted at a new platform or after platform-specific changes are made.

Skipping this step or bypassing a failed smoke check undermines the QA process and can introduce significant delays and defects into the release pipeline.

Important Notes

• Strict Pass/Fail Gate: The most important rule is that any build failing the smoke check must not proceed to QA. This prevents wasted effort and ensures that only builds meeting critical functional criteria are tested further.
• Automated, Not Exhaustive: Smoke Check covers only the critical paths and core features, not every edge case or full regression. It is not a substitute for comprehensive QA.
• Customizable Checks: Platform flags allow tailoring the smoke check to the nuances of each deployment environment, ensuring relevant validations are included.
• Documentation: All results are logged in date-stamped markdown files, supporting traceability and continuous improvement.
• Skill Permissions: Smoke Check leverages tools like Bash, Grep, and file operations. It should be executed in environments where these permissions are available.

By integrating Smoke Check into your development process, you establish a disciplined hand-off between development and QA, reduce friction, and enable your team to deliver higher-quality software more efficiently.