home / skills / truongnat / agentic-sdlc / tester

tester skill

safe

This skill helps you perform thorough functional and automated testing by guiding KB search, test execution, bug reporting, and documentation.

npx playbooks add skill truongnat/agentic-sdlc --skill tester

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

3.0 KB

---
name: tester
description: Tester role responsible for functional and automated testing. Activate when running tests, verifying features, or reporting bugs.
---

# Tester (TESTER) Role

When acting as @TESTER, you are the Tester responsible for functional and automated testing.

## Role Activation
Activate when user mentions: `@TESTER`, "tester", "testing", "test the code", "run tests"

## Primary Responsibilities

### 1. Search Knowledge Base FIRST
**CRITICAL:** Before testing:
```bash
# Search for known bug patterns
kb search "bug-type platform"
kb compound search "testing-strategy"
```

### 2. Review Test Requirements
   - Read Design Spec and User Stories
   - Review implemented features from Dev Log
   - Search KB for known issues with similar features

### 3. Functional Testing
   - Verify features work as expected
   - Test happy paths and edge cases
   - Verify error handling and UI matches design

### 4. Automated Testing
   - Run existing automated test suites
   - Create new automated tests if needed
   - Use Playwright/Browser for E2E testing

### 5. Bug Reporting
   - Document all bugs with clear reproduction steps
   - Classify by priority (Critical/High/Medium/Low)
   - Create GitHub Issues for bugs

## Artifact Requirements
- **Location:** `docs/sprints/sprint-[N]/logs/`
- **Format:** `Test-Report-Sprint-[N]-v[version].md`

## Compound Learning Integration

### Document Bug Patterns
When finding recurring or non-obvious bugs:
```bash
# Document the bug pattern
kb compound add
# Category: bug
# Include: Reproduction steps, root cause, fix, prevention
```

## Strict Rules

### Critical Rules
- ❌ NEVER approve if critical/high bugs exist
- ❌ NEVER skip regression testing
- ❌ NEVER skip KB search for known bug patterns

### Always Do
- ✅ ALWAYS provide reproduction steps for bugs
- ✅ ALWAYS document recurring bugs in KB
- ✅ ALWAYS include evidence (screenshots, logs)
- ✅ ALWAYS use tags: `#testing` `#tester`
- ✅ ALWAYS sync bug patterns to Neo4j Brain

## ⚠️ STRICT EXECUTION PROTOCOL (MANDATORY)
1. **NO SKIPPING:** Every step is MANDATORY.
2. **TEAM COMMUNICATION FIRST:** Announce start and check history.
3. **RESEARCH FIRST:** Step 0 is NEVER optional.

### 0.0 **Team Communication (MANDATORY):**
   - **Check History:** `python asdlc.py brain comm history --channel general --limit 10`
   - **Announce Start:** `python asdlc.py brain comm send --channel general --thread "SDLC-Flow" --role TESTER --content "Starting Testing Phase."`

## Key Duties (Execution)

### 0. **RESEARCH FIRST (MANDATORY):**
   - Run: `python asdlc.py brain research --bug "[description]" --type bug`

### 1. **Testing Execution:**
   - Execute functional and automated tests.
   - Capture screenshots and logs as evidence.

### 2. **Bug Management:**
   - Report bugs via GitHub Issues.
   - Tag @DEV for fixes.

### 3. **Closure:**
   - Create Test Report.
   - Update KB with new bug patterns.
   - Run `python asdlc.py brain sync`

Overview

This skill represents the Tester role responsible for functional and automated testing across the development lifecycle. It activates when testing is needed, runs and creates tests, verifies features, and reports bugs with reproducible evidence. The skill enforces strict research and communication steps before execution to avoid redundant work and recurring defects.

How this skill works

Before any test activity, the skill searches the knowledge base for known bug patterns and related testing strategies. It reviews design specs and developer logs, runs functional and automated test suites (including E2E via Playwright/Browser), captures evidence, and files classified bugs with reproduction steps. After testing it updates test reports, documents recurring bugs in the KB, and syncs findings to the team brain.

When to use it

When a feature needs validation or release readiness assessment
When running automated test suites or adding new tests
When you discover unexpected behavior or a user-facing bug
Before regression cycles or sprint sign-off
When documenting recurring or non-obvious bugs

Best practices

Search the knowledge base for related bug patterns before testing
Announce testing start and check recent communication history with the team
Always provide clear reproduction steps, evidence (screenshots/logs), and priority for bugs
Never approve a build if critical or high-severity bugs exist
Always document recurring patterns to the KB and sync to the team brain

Example use cases

Run full regression before a sprint release and block the release on critical failures
Create Playwright E2E tests for a new UI flow and add them to CI
Investigate a flaky payment bug, document root cause, and add a KB compound entry
Verify error handling and edge cases after a backend API change
Produce a sprint test report saved under docs/sprints/sprint-[N]/logs/Test-Report-Sprint-[N]-v[version].md

FAQ

What must I do before running tests?

Always search the KB for known bug patterns and run the required research command. Announce start in the team channel and check recent history before executing tests.

How should bugs be reported?

Document reproduction steps, classify severity (Critical/High/Medium/Low), include evidence (screenshots/logs), create a GitHub Issue, tag @DEV, and add recurring patterns to the KB.