lisa-cursor

Plugin lisa-cursor from marketplace lisa in CodySwannGT/lisa. Commands read from the repo's manifest — today.

Skills (170)

• lisa-acceptance-criteria
• lisa-agent-design-best-practices
• lisa-agent-ready
• lisa-analyze-claude-remote
• lisa-atlassian-access
• lisa-attribute-failure
• lisa-automation-status
• lisa-bug-triage
• lisa-capability-drift
• lisa-codebase-research
• lisa-codify-verification
• lisa-confluence-prd-intake
• lisa-confluence-to-tracker
• lisa-confluence-write-prd
• lisa-cross-pollinate
• lisa-debrief-apply
• lisa-debrief
• lisa-delivery-effectiveness
• lisa-design-intake
• lisa-detect-tooling
• lisa-doctor
• lisa-drive-pr-to-merge
• lisa-epic-triage
• lisa-evaluation-suite
• lisa-exploratory-qa
• lisa-fix-linter-error
• lisa-generate-claude-remote-build-script
• lisa-git-commit
• lisa-git-prune
• lisa-git-submit-pr
• lisa-github-add-journey
• lisa-github-build-intake
• lisa-github-claim
• lisa-github-create
• lisa-github-evidence
• lisa-github-journey
• lisa-github-prd-intake
• lisa-github-project-v2
• lisa-github-read-issue
• lisa-github-sync
• lisa-github-to-tracker
• lisa-github-validate-issue
• lisa-github-verify
• lisa-github-write-issue
• lisa-github-write-prd
• lisa-health-drift-cron
• lisa-health
• lisa-implement
• lisa-improve-code-complexity
• lisa-improve-harness
• lisa-improve-max-lines-per-function
• lisa-improve-max-lines
• lisa-improve-test-coverage
• lisa-improve-tests
• lisa-intake-explain
• lisa-intake
• lisa-jam-access
• lisa-jira-add-journey
• lisa-jira-build-intake
• lisa-jira-claim
• lisa-jira-create
• lisa-jira-evidence
• lisa-jira-journey
• lisa-jira-read-ticket
• lisa-jira-sync
• lisa-jira-validate-ticket
• lisa-jira-verify
• lisa-jira-write-ticket
• lisa-jsdoc-best-practices
• lisa-kane-browser
• lisa-learnings-audit
• lisa-linear-access
• lisa-linear-add-journey
• lisa-linear-build-intake
• lisa-linear-claim
• lisa-linear-create
• lisa-linear-evidence
• lisa-linear-journey
• lisa-linear-prd-intake
• lisa-linear-read-issue
• lisa-linear-sync
• lisa-linear-to-tracker
• lisa-linear-validate-issue
• lisa-linear-verify
• lisa-linear-write-issue
• lisa-linear-write-prd
• lisa-monitor
• lisa-nightly-add-test-coverage
• lisa-nightly-improve-tests
• lisa-nightly-lower-code-complexity
• lisa-notion-access
• lisa-notion-prd-intake
• lisa-notion-to-tracker
• lisa-notion-write-prd
• lisa-parity-code-review
• lisa-parity-coderabbit
• lisa-parity-sentry-sdk-setup
• lisa-parity-sentry-seer
• lisa-performance-review
• lisa-persist-learning
• lisa-plan
• lisa-plugin-sync-explain
• lisa-posthog-access
• lisa-prd-backlink
• lisa-prd-source-write
• lisa-prd-ticket-coverage
• lisa-product-walkthrough
• lisa-project-ideation
• lisa-pull-request-review
• lisa-quality-review
• lisa-queue-status
• lisa-remote-dispatch
• lisa-repair-intake
• lisa-reproduce-bug
• lisa-research
• lisa-review-implementation
• lisa-review-local
• lisa-rework-triage
• lisa-root-cause-analysis
• lisa-secrets-access
• lisa-security-review
• lisa-security-zap-scan
• lisa-sentry-access
• lisa-session-manager
• lisa-setup-atlassian
• lisa-setup-automations
• lisa-setup-confluence
• lisa-setup-github-repo
• lisa-setup-github
• lisa-setup-jira
• lisa-setup-kane
• lisa-setup-linear
• lisa-setup-local-env
• lisa-setup-notion
• lisa-setup-remote-aws
• lisa-setup-remote-env
• lisa-setup-session-manager
• lisa-setup-sonar
• lisa-setup-workstation
• lisa-sonarcloud-access
• lisa-spec-conformance
• lisa-starter-sync
• lisa-sync-down
• lisa-task-decomposition
• lisa-task-triage
• lisa-tdd-implementation
• lisa-tear-down-automations
• lisa-test-strategy
• lisa-ticket-triage
• lisa-track
• lisa-tracker-add-journey
• lisa-tracker-build-intake
• lisa-tracker-claim
• lisa-tracker-create
• lisa-tracker-evidence
• lisa-tracker-journey
• lisa-tracker-read
• lisa-tracker-source-artifacts
• lisa-tracker-sync
• lisa-tracker-validate
• lisa-tracker-verify
• lisa-tracker-write
• lisa-usage-accounting
• lisa-use-the-product
• lisa-validate-tracker-mapping
• lisa-verification-lifecycle
• lisa-verify-prd
• lisa-verify-workflow-change
• lisa-verify
• lisa-wiki-install

Slash commands (70)

• /lisa-cursor:lisa:agent-ready

  Make a brownfield project agent-ready: build the initial knowledge wiki through read-only, redacted ingestion, persist complete/partial/unavailable coverage for every source, write wiki/gaps.md with the questions only a human can answer, and converge over re-runs until every source is complete and z

• /lisa-cursor:lisa:analyze-claude-remote

  Audit whether this repository can run as a Claude Code remote routine (cloud session) and inventory everything Lisa AND the host project must install or configure in the cloud environment — CLIs/binaries, environment variables/secrets, startup hooks, MCP scope/auth, and the user-scoped config and au

• /lisa-cursor:lisa:attribute-failure

  Attribute an arbitrary failure event to Lisa or the project with cited evidence. Evaluates three ordered signals — Lisa-managed surface ownership, shipped rule/skill/hook behavior, and the upstream Lisa change-history window — and returns lisa | project | ambiguous. Read-only; inconclusive cases sta

• /lisa-cursor:lisa:automation-status

  Inspect the current project's Lisa automation fleet and report whether the expected recurring jobs exist, match Lisa's setup contract, and show healthy recent activity. Read-only by default.

• /lisa-cursor:lisa:codify-verification

  Convert empirical verification into a regression test (Playwright for UI, integration test for API/DB, benchmark for performance, etc.) so it doesn't regress. Mandatory step after verification passes — invoked from verification-lifecycle and from each Build/Fix/Improve flow.

• /lisa-cursor:lisa:cross-pollinate

  Detect locally-authored agent definitions and regenerate them in the formats of the other coding agents this project supports (per .lisa.config.json).

• /lisa-cursor:lisa:debrief

  Debrief a shipped initiative — mine tickets, PRs, and review threads to surface candidate learnings (edge cases, gotchas, friction, tooling gaps, convention drift) for human triage. Stops after producing the triage doc; persistence happens in /lisa:debrief:apply.

• /lisa-cursor:lisa:debrief:apply

  Apply human-marked dispositions from a Debrief triage document — route accepted learnings to their persistence destinations (Edge Case Brainstorm checklist, project rules, memory, tracker tickets). Reads the triage doc produced by /lisa:debrief; deterministic and idempotent.

• /lisa-cursor:lisa:design:intake

  Design-handoff gate for a work item with a UI surface. Resolves the source of truth per axis (colour, spacing, typography, radius, elevation, motion) by querying the configured design source's published variable collections — never by asking a human — then judges the item against the five objectivel

• /lisa-cursor:lisa:detect-tooling

  Find the command-line tools this project needs but never declares, and propose pinned manifest entries for them. Reads npm scripts, MCP servers, credential usage notes and quality configuration, subtracts what remoteEnv.tools already covers, and prints proposals with evidence. Writes nothing and ins

• /lisa-cursor:lisa:doctor

  Audit whether the current repository is ready to use Lisa. Runs grouped read-only readiness checks for config, runtime surfaces, tracker/source access, automation prerequisites, and optional GitHub Project/wiki coordination, then reports PASS/WARN/FAIL/SKIP results plus an overall verdict.

• /lisa-cursor:lisa:exploratory-qa

  Run a first-time-user exploratory QA pass on any product type (DOM web app, HTTP/API backend, canvas game, CLI/library, IaC/CDK): experience the product the way a brand-new end user would by driving its real consumer-facing interface via the use-the-product core (which detects the product type, reso

• /lisa-cursor:lisa:fix:linter-error

  Fix all violations of one or more ESLint rules across the codebase

• /lisa-cursor:lisa:generate-claude-remote-build-script

  Generate the setup/build script and environment-variable template to paste into a Claude Code remote routine environment so this repo runs in the cloud. Runs /lisa:analyze-claude-remote, then writes an idempotent, detect-before-install bash script that installs the required package manager and CLIs

• /lisa-cursor:lisa:git:commit

  Create conventional commits for current changes

• /lisa-cursor:lisa:git:prune

  Prune local branches that have been deleted on remote

• /lisa-cursor:lisa:git:submit-pr

  Push changes and create or update a pull request

• /lisa-cursor:lisa:health-drift-cron

  Run the scheduled health consumer: check health headless, and file one deduped ticket per drifting check.

• /lisa-cursor:lisa:health

  Run Lisa Health through the current coding-agent harness and emit the final persisted Health v1 JSON result.

• /lisa-cursor:lisa:implement

  Implement a single work item end-to-end. Vendor-agnostic: given a work-item URL/key (JIRA, Linear, GitHub Issues) or description, reads it, determines work type (Build/Fix/Improve/Investigate), assembles an agent team, runs the full lifecycle through PR + evidence. Pass executionEnv=codex-cloud to r

• /lisa-cursor:lisa:improve-harness

  Use after ONE run went wrong, to find the real cause and prove the fix worked. Investigates a single failed or expensive factory trajectory end to end: records the job contract, observes the baseline, locates the earliest failed handoff, classifies the gap (context | capability | domain-ownership |

• /lisa-cursor:lisa:improve:code-complexity

  Reduce the cognitive complexity threshold by 2 and fix all violations

• /lisa-cursor:lisa:improve:max-lines-per-function

  Reduce max lines per function threshold and fix violations

• /lisa-cursor:lisa:improve:max-lines

  Reduce max file lines threshold and fix violations

• /lisa-cursor:lisa:improve:test-coverage

  Increase test coverage to a specified threshold percentage

• /lisa-cursor:lisa:improve:tests

  Improve test quality by analyzing and strengthening weak, brittle, or poorly-written tests

• /lisa-cursor:lisa:intake-explain

  Inspect one PRD or build item, explain how Lisa classifies it right now, and report the exact intake or repair gate affecting it. Read-only by default.

• /lisa-cursor:lisa:intake

  Vendor-agnostic batch scanner for Ready queues. Notion PRD database URL → finds Status=Ready PRDs and runs lisa-plan per item. Confluence space or parent-page URL → finds prd-ready PRDs and runs lisa-plan per item. Linear workspace or team URL → finds prd-ready Linear projects and runs lisa-plan per

• /lisa-cursor:lisa:learnings:audit

  Run one gardener cycle over this project's knowledge surfaces (the learnings ladder, PRD #1729): inventory ledger/rules/skills/wiki/mechanical controls, gather evidence, classify via the ladder router, and file human-gated tracker tickets — per-item PROMOTE/DEMOTE tickets, one CONFIRM/RETIRE batch t

• /lisa-cursor:lisa:monitor

  Monitor application health AND audit observability completeness for the current repo, then file build-ready tickets for anomalies and instrumentation gaps. Health/logs/errors/performance via the stack ops-specialist or stack-agnostic base probing; repo-scoped, idempotent, capped; files by default, -

• /lisa-cursor:lisa:parity-code-review

  Lisa-native code review of the current git diff — correctness bugs, security issues, and obvious defects, reported as severity-ranked findings with file:line references. Vendor-neutral cross-agent equivalent of the upstream code-review command.

• /lisa-cursor:lisa:parity-coderabbit

  Thorough PR-style review of the full diff — bugs, security, performance, and maintainability — with concrete fixes and a structured summary. An independent Lisa-native review (does NOT call CodeRabbit's service); vendor-neutral cross-agent equivalent of the upstream coderabbit plugin.

• /lisa-cursor:lisa:parity-sentry-sdk-setup

  Install and configure the Sentry SDK for a project — detect the framework, add the right @sentry/<framework> package, init the client, wire the DSN via env, enable error + performance monitoring, and set up source maps. One consolidated skill covering react, nextjs, node, nestjs, python, react-nativ

• /lisa-cursor:lisa:parity-sentry-seer

  AI debugging — given an error, stack trace, or failing test, analyze it, form ranked hypotheses, locate the root cause in the codebase with file:line evidence, and propose a minimal fix. Lisa-native reimplementation of Sentry's seer workflow.

• /lisa-cursor:lisa:persist-learning

  Route a candidate learning through the hostile-default learning-judge gate and act on the verdict: leave a dropped-with-reason note on the triggering issue (drop), file the upstream Lisa ticket automatically with marker dedupe, evidence, and a per-run cap (lisa-upstream), or persist a durable learni

• /lisa-cursor:lisa:plan

  Plan work from a single PRD or specification. Decomposes into ordered work items in the configured tracker (JIRA, GitHub Issues, or Linear per .lisa.config.json). Source can be a Notion / Confluence / Linear / GitHub Issue URL, a JIRA epic key, a markdown file, or a free-form description. For batch

• /lisa-cursor:lisa:plugin-sync-explain

  Explain plugin source/generated drift and marketplace registration gaps without modifying the working tree.

• /lisa-cursor:lisa:product-walkthrough

  Walk through the live product via a real browser controlled interactively through any capable backend to ground PRD evaluation or ticket creation in what exists today. Captures current behavior, design-vs-product divergence, reuse candidates, and behavioral surprises.

• /lisa-cursor:lisa:project-ideation

  Generate persona-grounded, verifiable product ideas for the host project, then create PRDs for the selected build-ready ideas via lisa-research. First derives the personas the project actually serves (from its docs, code, data model, and releases — never invented), ideates per persona, and gates eac

• /lisa-cursor:lisa:pull-request:review

  Address and resolve PR review comments (human + bot): implement valid feedback, reply to invalid, resolve every thread.

• /lisa-cursor:lisa:queue-status

  Inspect the current project's PRD and build queues, summarize lifecycle counts, and surface actionable queue-health signals without mutating work.

• /lisa-cursor:lisa:repair-intake

  Repair counterpart to /lisa:intake. Vendor-agnostic batch scanner that finds stuck or half-closed work — items in `blocked`, stalled in an in-progress role (build `claimed`, PRD `in_review`), terminal-labeled items still natively open, rollups whose children are all terminal, GitHub PRDs missing nat

• /lisa-cursor:lisa:research

  Research a problem space and create a PRD in the configured PRD source. Investigates the codebase, defines user flows, assesses technical feasibility, synthesizes the spec, then creates it in the source (Notion / Confluence / GitHub / Linear) via lisa-prd-source-write — no loose document. prd_ready=

• /lisa-cursor:lisa:review:local

  Review local branch changes compared to main

• /lisa-cursor:lisa:rework-triage

  Detect whether a ticket is rework bounced back from QA/staging, classify why the previous agent attempt failed, and route the cause to its hardening destination (upstream Lisa issue, provisioning ticket, or PRD defect flag).

• /lisa-cursor:lisa:security:zap-scan

  Run an OWASP ZAP baseline security scan locally using Docker

• /lisa-cursor:lisa:session-manager

  Run the local session manager: one dispatch-and-relay cycle (the /loop prompt), or start, stop or show the tmux-hosted manager. Dispatches Ready work items to fresh background worker sessions and relays their questions over the project's Telegram bot when one is configured (Telegram is optional). Cl

• /lisa-cursor:lisa:setup-automations

  Set up the recurring Lisa automations on the local workstation using the runtime's native scheduler (Codex automations / Claude /schedule): intake-repair (60 min), intake PRD (60 min), intake tickets (10 min), exploratory-bugs (daily), exploratory-prds (daily). A declarative spec — it states what to

• /lisa-cursor:lisa:setup-remote-aws

  Install Lisa's vendor-neutral AWS CLI bootstrap and platform adapters for remote coding environments.

• /lisa-cursor:lisa:setup:atlassian

  Set up Atlassian (cloudId + acli profile) for this project. Writes the `atlassian` section of `.lisa.config.json` and enables the Atlassian MCP and/or installs acli as needed. Prerequisite for /lisa:setup:jira and /lisa:setup:confluence.

• /lisa-cursor:lisa:setup:confluence

  Set up Confluence as the PRD source for this project. Writes the `confluence` section of `.lisa.config.json` (spaceKey and/or parentPageId) and offers to set top-level `source: \"confluence\"`. Depends on /lisa:setup:atlassian.

• /lisa-cursor:lisa:setup:github-repo
• /lisa-cursor:lisa:setup:github
• /lisa-cursor:lisa:setup:jira
• /lisa-cursor:lisa:setup:linear
• /lisa-cursor:lisa:setup:local-env
• /lisa-cursor:lisa:setup:notion
• /lisa-cursor:lisa:setup:remote-env
• /lisa-cursor:lisa:setup:session-manager
• /lisa-cursor:lisa:setup:sonar
• /lisa-cursor:lisa:setup:workstation
• /lisa-cursor:lisa:starter-sync
• /lisa-cursor:lisa:sync-down
• /lisa-cursor:lisa:tear-down-automations
• /lisa-cursor:lisa:track
• /lisa-cursor:lisa:validate-tracker-mapping
• /lisa-cursor:lisa:verify-prd
• /lisa-cursor:lisa:verify-workflow-change
• /lisa-cursor:lisa:verify
• /lisa-cursor:lisa:wiki:install

Subagents (29)

• architecture-specialist

  Architecture specialist agent. Designs implementation approaches, traces data flow, identifies files to modify, maps dependencies, finds reusable code, evaluates design patterns, and flags breaking changes.

• bug-fixer

  Bug fix agent. Reproduces bugs as failing tests, implements fixes via TDD, and verifies the fix resolves the issue without introducing regressions.

• builder

  Feature build agent. Translates acceptance criteria into tests, implements features via TDD, and verifies all criteria are met.

• confluence-prd-intake

  PRD intake agent for Confluence-hosted PRDs. Runs one intake cycle against a Confluence space or parent page — claims PRDs carrying the configured `ready` label (relabels to the configured `in_review` label), validates each through the dry-run pipeline, and routes to the configured `blocked` label (

• debug-specialist

  Debug specialist agent. Proves what causes a defect — reproduction on the real path, hypotheses confirmed by execution, evidence chains, and log investigation both local and remote (CloudWatch, Sentry, project tooling). Escalates an unresolved verdict with a decision-ready packet rather than guessin

• eval-specialist

  Evaluation specialist agent. Measures the factory itself rather than the software it produces — maintains the entity's own task suite, samples it against a recorded baseline to catch capability decline, and reports delivery effectiveness alongside autonomy. Independent of the agents it judges by con

• git-history-analyzer

  Analyzes git commit history and pull request context to document the decision-making process behind file changes. Use when you need to understand why and how files evolved over time.

• github-agent

  GitHub Issues lifecycle agent. Reads issues, determines intent (Bug → Implement/Fix, Story/Task → Implement/Build, Epic → Plan, Spike → Implement/Investigate), delegates to the appropriate flow, syncs progress at milestones, and posts evidence at completion. The GitHub counterpart of jira-agent.

• github-build-intake

  GitHub build-intake agent. Runs one build-intake cycle against a GitHub repository — claims issues carrying the configured `ready` build label, dispatches each to the github-agent build flow, relabels to the configured (env-aware) `done` label on success. Symmetric counterpart to jira-build-intake.

• github-prd-intake

  PRD intake agent for GitHub Issues hosted PRDs. Runs one intake cycle against a GitHub repository — claims issues carrying the configured `ready` PRD label (relabels to the configured `in_review` label), validates each through the dry-run pipeline, and routes to the configured `blocked` label (with

• jira-agent

  JIRA lifecycle agent. Reads tickets, determines intent (Bug → Implement/Fix, Story/Task → Implement/Build, Epic → Plan, Spike → Implement/Investigate), delegates to the appropriate flow, syncs progress at milestones, and posts evidence at completion.

• jira-build-intake

  JIRA build-intake agent. Runs one build-intake cycle against a JIRA project (or JQL filter) — claims tickets in the configured `ready` status, dispatches each to the jira-agent build flow, transitions to the configured (env-aware) `done` status on success. Symmetric counterpart to notion-prd-intake.

• learner

  Post-implementation learning agent. Capture-only — collects task learnings, builds eight-field entries, and persists them to the machine-managed ledger through the executable contract with provenance. Never promotes: it creates no skills, appends no rules, files no upstream issues; promotion is excl

• learning-judge

  Skeptical judgment gate for candidate learnings. Classifies each candidate as durable-learning, planning-miss, one-off, misunderstanding/spec-gap, or lisa-upstream with mandatory evidence citation. Hostile default — most candidates are DROPPED; only durable-learning and planning-miss (a dispatched i

• learnings-synthesizer

  Learnings synthesizer for the Debrief flow. Consumes the parallel outputs of tracker-mining-specialist and pr-mining-specialist, deduplicates, categorizes each candidate into one of {edge case, recurring gotcha, process friction, tooling gap, convention drift, decomposition infidelity, prd defect, m

• linear-agent

  Linear lifecycle agent. Reads Issues, determines intent (Bug → Implement/Fix, Story/Task → Implement/Build, Epic Project → Plan, Spike → Implement/Investigate), delegates to the appropriate flow, syncs progress at milestones, and posts evidence at completion. Linear counterpart of jira-agent and git

• linear-build-intake

  Linear build-intake agent. Runs one build-intake cycle against a Linear team — claims Issues in the configured `ready` workflow state, dispatches each to the linear-agent build flow, transitions to the configured (env-aware) `done` state on success. Symmetric counterpart of jira-build-intake and git

• linear-prd-intake

  PRD intake agent for Linear-hosted PRDs. Runs one intake cycle against a Linear workspace or team — claims projects carrying the configured `ready` PRD label (relabels to the configured `in_review` label), validates each through the dry-run pipeline, and routes to the configured `blocked` label (wit

• notion-prd-intake

  PRD intake agent. Runs one intake cycle against a Notion PRD database — claims PRDs in the configured `ready` status, validates each through the dry-run pipeline, and routes to the `blocked` status (with clarifying comments) or the `ticketed` status (with destination tickets created). Designed to be

• performance-specialist

  Performance specialist agent. Identifies N+1 queries, inefficient algorithms, memory leaks, missing indexes, unnecessary re-renders, bundle size issues, and other software performance problems. Recommends optimizations with evidence.

• pr-mining-specialist

  PR mining specialist for the Debrief flow. Walks every PR linked from a shipped initiative — description, review comments (CodeRabbit + human, general + inline), every commit on the branch (especially late `fix:` / `revert:` follow-ups), and every test file added — and produces a structured findings

• product-specialist

  Product/UX specialist agent. Defines user flows in Gherkin, writes acceptance criteria from user perspective, identifies UX concerns and error states, and empirically verifies behavior matches requirements.

• quality-specialist

  Code quality specialist agent. Reviews correctness, coding philosophy compliance (immutability, function structure), test coverage, and documentation. Explains findings in beginner-friendly plain English, ranked by severity.

• security-specialist

  Security specialist agent. Performs threat modeling (STRIDE), reviews code for OWASP Top 10 vulnerabilities, checks auth/validation/secrets handling, and recommends mitigations.

• skill-evaluator

  Six-rung ladder router for candidate learnings. Given a candidate (rule, why, provenance, evidence) it recommends a destination rung — EXECUTABLE-CONTROL | EAGER-RULE | SKILL | WIKI | KEEP-IN-LEDGER | RETIRE — and a scope (project | upstream), with a plain-language rationale and a drafted artifact.

• spec-conformance-specialist

  Spec conformance specialist agent. Verifies shipped work matches its spec exactly — acceptance criteria, Out of Scope, Technical Approach, Validation Journey assertions, and deliverables. Produces a coverage matrix, flags scope creep separately from misses, and issues a verdict (CONFORMS / PARTIAL /

• test-specialist

  Test specialist agent. Designs test strategy (matrix, edge cases, coverage targets, TDD sequence), writes comprehensive unit and integration tests, and reviews test quality. Tests behavior, not implementation details.

• tracker-mining-specialist

  Tracker mining specialist for the Debrief flow. Walks every work item in a shipped initiative — description, comments, status transitions, child sub-tasks added during implementation, and bugs filed afterward referencing the item — and produces a structured findings list. Pairs with pr-mining-specia

• verification-specialist

  Verification specialist agent. Discovers project tooling and executes verification for all required types. Plans and executes empirical proof that work is done by running the actual system and observing results.

Similar plugins