falsegreen-skill
LLM-based semantic analysis for false-positive test detection. This skill judges whether a test genuinely verifies correct behavior, across Python, TypeScript, JavaScript, and Robot Framework - and catches semantic patterns no static tool can see.
Install / Use
npx skills add hashgraph-online/awesome-codex-plugins --skill falsegreen-skillInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AI & Machine LearningSupported Platforms
Our assessment of falsegreen-skill
falsegreen-skill scores 93/100 on our quality scale, 259th of 950 AI & Machine Learning skills we index (top 28%).
Its SKILL.md is 36 KB long, well organised into 30 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.
With 1,075 GitHub stars, it is one of the more widely adopted skills in the catalogue.
Maintenance, license and trust
- The repository was last updated about 2 months ago, so falsegreen-skill is actively maintained.
- Our last check on 2026-10-25 found the source still online.
- It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
- Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit โ read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk โ read a skill before letting an agent act on it.
falsegreen-skill compared with similar skills
All 4 of these similar skills score higher than falsegreen-skill; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| falsegreen-skill (this skill)by hashgraph-online | 93 | 1.1k | 53d ago | SKILL.md |
| claude-memby thedotmack | 100 | 117.6k | today | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 112.3k | 9d ago | CLAUDE.md |
| Understand-Anythingby Egonex-AI | 100 | 92.8k | 1d ago | CLAUDE.md |
| rufloby ruvnet | 100 | 81.9k | today | CLAUDE.md |
Frequently asked questions
- How do I install falsegreen-skill?
- Run
npx skills add hashgraph-online/awesome-codex-plugins --skill falsegreen-skill. The install tabs above show the steps for each supported agent. - Which AI agents does falsegreen-skill work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is falsegreen-skill safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is falsegreen-skill still maintained?
- The repository was last updated about 2 months ago, so falsegreen-skill is actively maintained.
Skill content
View source on GitHubfalsegreen-skill
LLM-based semantic analysis for false-positive test detection. This skill judges whether a test genuinely verifies correct behavior, across Python, TypeScript, JavaScript, and Robot Framework - and catches semantic patterns no static tool can see.
For Python, this skill applies the complete falsegreen catalog directly โ all structural and semantic patterns โ without requiring the static scanner to run first. The companion falsegreen scanner is a faster batch alternative for Python; results must be consistent with this skill. For TypeScript and JavaScript, this skill is the primary detection tool.
Invoke by attaching a test file or pasting a test snippet and asking for false-positive analysis.
The one rule
A test is useful only if it fails when the code breaks. Every pattern this skill looks for is a variation on tests that do not fail: tests that pass while the code is wrong, tests that check the wrong thing, or tests that borrow correctness from elsewhere.
Three intents, one skill
This is one skill with one source of truth (the J1-J6 judgments and the catalog
in reference.md), used in three directions. Pick the intent from what the user asks:
- Review an existing test ("analyze / check / is this test real?") -> Mode A (the Protocol below): detect false-green smells and report them.
- Create a test ("write / generate a unit|integration|e2e test for X in <language>") -> Mode B (Authoring mode, at the end of this file): generate the test, then run Mode A on your own output until it is clean.
- Fix a finding ("strengthen / repair this false-green test", given a falsegreen report) -> Mode C (AI-fix mode, after Mode B): propose a strengthened test that closes the finding, self-validated with Mode B's machinery, plus the validation contract the host runs to confirm it.
Generation does not have its own rules. The test you write must pass the same J1-J6 it would be judged by, so it is born non-false-green. The developer chooses the language and the pyramid level; the catalog is the guard either way. The fix path reuses that same loop: a proposed fix is just an authored test that has to survive its own review before the host runs the gate.
Protocol
Work through these steps in order. Do not skip steps.
Step 0 (optional): Load project conventions
If the user supplies a conventions: block, incorporate it before applying any judgments.
This block declares project-specific context that affects the look-alike rules.
Example:
conventions:
custom_assertion_helpers:
- conftest.assert_model_valid() # wraps assert + validation logic
- helpers.assert_valid_uuid()
test_layer_overrides:
- tests/integration/ is web-layer # apply C6 HTTP exemption here
excluded_codes:
- C8 # project uses Decimal, not float
The conventions block does NOT disable severity levels. It only extends the look-alike exemptions in reference.md. HIGH findings that survive after exemptions are still reported as HIGH.
If no conventions block is provided, proceed directly to Step 1.
Step 1: Detect language and framework
Identify:
- Language: Python / TypeScript / JavaScript / Robot Framework
- Test framework: pytest / unittest (Python) ยท Jest / Vitest / Mocha+Chai (TS/JS) ยท
React Testing Library (component render) ยท Cypress / Playwright (E2E, JS/TS or Python) ยท
Robot Framework (
.robot/.resource, keyword-driven) ยท Tavern (*.tavern.yaml, API) ยท Gherkin/BDD (.feature: Cucumber.js / behave / pytest-bdd) - Test level โ read it from the signals below, do not guess. The level changes what counts as a valid oracle.
How to tell the level. Read it from the signals; do not guess. Apply this precedence (strongest signal wins), in order:
- A doubled boundary beats an import. If an interceptor or fake wraps the boundary -
Python
responses/respx/requests-mock/vcr/moto/fakeredis/mongomock/pyfakefs/unittest.mock/monkeypatch; JS/TSmsw/nock/fetch-mock/axios-mock-adapter/jest.mock/vi.mock/aws-sdk-client-mock- the test is unit/component even when a real client (requests,axios,boto3, SQLAlchemy) is imported. The mock IS the boundary. - Else a real boundary makes it integration. A real HTTP client / in-process test client, DB driver/ORM, queue, cache, or storage SDK that touches a real (even ephemeral or containerized) collaborator.
- Else a browser/mobile driver makes it E2E.
- No signal โ unit. Real I/O (disk, clock, network) in a test with no integration signal is itself the smell, not the level.
| Signal | Unit (and component) | Integration | E2E |
|---|---|---|---|
| Path / marker | tests/unit/, none, co-located *.test.ts | tests/integration/, *.int.test.ts, @pytest.mark.integration/functional/db/django_db | tests/e2e/, cypress/e2e/, *.e2e-spec.ts, *.cy.ts, @pytest.mark.e2e/acceptance, playwright.config |
| Doubles | mock/patch or intercept the boundary (rule 1) | real client/driver, no double | no double at all |
| Component render | RTL / Vue Test Utils / Angular TestBed / cy.mount / Storybook with mocked network, jsdom/happy-dom - counts as unit for the oracle | โ | full app in a real browser |
| API | none, or HTTP intercepted | in-process test client (FastAPI/Starlette TestClient, Flask/Django/DRF client, supertest request(app), Nest TestingModule) or a real client to a live URL; gRPC/GraphQL/WebSocket; RequestsLibrary/RESTinstance; asserts status/body | full app behind the browser |
| Database / store | repository or in-memory fake, mocked client | real ORM/driver (SQLAlchemy, Django ORM, Prisma, TypeORM, Drizzle, Knex, psycopg, asyncpg, mongoose, pymongo, redis, ioredis), testcontainers, session/transaction; sqlite :memory: and *-memory-server lean integration | DB reached through the UI |
| Other I/O | mocked (moto / @mock_aws, aws-sdk-client-mock) | real queue (Kafka, RabbitMQ, SQS, bullmq), object storage (real S3, or a LocalStack / testcontainers emulator - a real service over the wire, not moto), email/SMTP, subprocess, cache | โ |
| UI / browser | none | none | Playwright page./expect(page), Cypress cy.visit, WebdriverIO browser., Puppeteer, Selenium driver., Robot SeleniumLibrary/Browser/AppiumLibrary; selectors, navigation |
A conventions: block (Step 0) with test_layer_overrides wins over all of this. Markers like
smoke/slow/asyncio/anyio are level-neutral: do not read a layer from them. When an
explicit marker/path says one level but the test mocks the whole boundary, trust the reality
(rule 1) and note the mismatch. When no signal is present, treat it as unit and say so.
Robot Framework: the level is dominated by the imported Library in *** Settings *** -
SeleniumLibrary / Browser / AppiumLibrary โ E2E; RequestsLibrary / RESTinstance / RPA.HTTP โ
API integration; DatabaseLibrary โ DB; SSH/FTP/Imap/Process โ system integration. Robot suites
are rarely unit. The full per-framework cue list lives in reference.md.
Why the level matters: in E2E/UI tests the presence of a response, page, or element IS the assertion at that layer - do not flag it as a weak check (affects C6 and C14). The level itself can be the smell: a real API or database call inside a test that presents as a unit test is a mystery-guest / over-mocking-inverted finding (J3/J6), not a valid integration test.
See reference.md for framework- and level-detection cues.
Step 2: Apply the full Python pattern catalog (Python only)
If the language is Python, scan the file against all falsegreen patterns
before proceeding to the semantic judgments. These patterns are organized in
reference.md under "Python" by family. Apply them in order:
| Family | Codes | What to look for | |---|---|---| | A โ never checks | C1, C2, C2b, C2c, C3, C4, C4b, C20, C21, C38, C39, C43, C45, C49, C50, C51, C59, CC | assertion unreachable, missing, swallowed, uncollected, name-shadowed, returned-not-asserted, discarded-comparison statement, empty/multi-call raises-warns context, captured log/output never asserted, skipped mid-test, empty parametrize | | B โ weak/always-true | C5, C6, C6b, C6c, C7, C8, C8b, C9, C11a, C13, C13b, C14, C16, C18, C25, C34, C42, C44, C52, C55, C56, C57 | tautology, truthiness-only, self-compare, broad exception, string repr, generator/lambda always truthy, numeric tautology, membership self-confirmation, mock-rooted compare, never-awaited coroutine, unconfigured Mock attribute | | C โ checks own setup | C19, C28, C29, C48 | pytest.raises wraps too much, binding unread, env mutation, test-mode flag flipped then asserted | | D โ external state | C17, C23, C24, C27, C30, C31, C32, C35 | skip-on-failure, hard path, shared mutable, try/pass, flaky | | E โ wrong thing | C33, C36, C37, C41 | metric not asserted, fail without reason, duplicate case, assert on a None-returning mutator | | Optional / diagnostic (opt-in) | C22, D1, D3, D4, D5, D6, D7, D8, M2 | apply only when user requests diagnostic pass |
Report each structural finding with its code number and confidence level before proceeding to Steps 3-6.
Relationship with the falsegreen scanner: if the user has already run
falsegreen <file> and provides its output, use that as the structural pass
result and proceed directly to Step 3 for findings the scanner marked as
needing semantic review. If no scanner output is provided, apply Step 2 fully.
For TypeScript and JavaScript, apply the TS/JS catalog below, then proceed to Step 3.
Step 2b: Apply the TypeScript / JavaScript pattern catalog (TS/JS only)
The companion static scanner for these languages is falsegreen-js. It shares the C-codes where the smell is the same concept and adds JS-specific codes. Apply the catalog, then proceed to Step 3 for the semantic judgments no static pass can make.
Load reference.md first (mandatory for non-Python). The table below is a
summary. The full JS-series, the Robot R-codes, and the PL config-audit codes are
defined only in reference.md. Read the matching language section in full before
judging any TypeScript, JavaScript, or Robot Framework test - do not rely on this
summary table alone. For Python, the structural catalog in Step 2 above is
complete on its own.
The S-series is separate, and it applies to every language including Python.
S1-S18 and S21 sit in reference.md, in the section
## Patterns only the semantic pass can catch (AI-only), which sits above the
per-language sections, so loading a language section alone skips all of them. Load
that section together with the "Look-alikes - do NOT flag" paragraph that closes
it. When the host budget cannot hold both the semantic
section and a language section, load the two floor fragments instead of the prose:
fragments/semantic-cases-compact.md (a row per S-code) plus
fragments/semantic-exemptions.md (the same look-alike exemptions, so the floor
needs no reference.md read at all). That is about 7.5 KiB against about 13 KiB.
The language section is what you defer and pull per finding, never the semantic
floor.
| Family | Codes | What to look for |
|---|---|---|
| A - never checks | C2, C2b, C21, CC, JS2, JS4, JS6, JS9, JS11 | empty test, no assertion, every assertion conditional, commented-out assertion, expect() without a matcher, skipped (it.skip/xit), empty describe, dead literal branch, swallowed try/catch |
| B - weak / always-true | C5, C7, C8, C9, C16, C18, JS3 | tautology, self-compare, exact float equality, toThrow() with no error type, time/randomness, stringified equality, snapshot-only |
| C - focus / async | JS1, JS5, JS7 | focused test (it.only/fit), async query/event not awaited, assertion in a non-awaited callback |
| D - duplicate | C37 | duplicate it.each/test.each case
Truncated for display โ read the full file on GitHub.
Related Skills
claude-mem
117.6kPersistent Context Across Sessions for Every Agent โ Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
Agent-Reach
112.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu โ one CLI, zero API fees.
Understand-Anything
92.8kGraphs that teach > graphs that impress. Turn any code into an interactive knowledge graph you can explore, search, and ask questions about. Works with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and more.
ruflo
81.9k๐ The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit โ see the Safety scan above for what the skill file itself contains.
