Pci Secure Software logo

Pci Secure Software

Organization
transilienceai
pci-secure-software

Automated PCI Secure Software Standard (SSS) v2.0 readiness gap-assessment of an application from its source code and documentation. Deterministically enumerates every applicable Test Requirement from a pinned catalog, gathers source/doc evidence, and emits an evidence-bound per-requirement verdict (MET / NOT_MET / PARTIALLY_MET / NOT_APPLICABLE / REQUIRES_MANUAL_REVIEW) with file+line citations, then a Transilience gap report. Use when asked to assess, gap-assess, or check an application's readiness against the PCI Secure Software Standard v2.0 / PCI SSF, or to map source code and design docs to PCI SSS Security Objectives and Test Requirements. Produces a readiness gap-analysis only — NOT an official PCI validation.

Overview

Publishertransilienceai
Repositorycommunitytools
Skill namepci-secure-software
Stars
565
Forks
81
Bundled files
25
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 25 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by transilienceai on GitHub. Read the source before you install it.

Installation

Install the Pci Secure Software AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
    https://github.com/transilienceai/communitytools/tree/main/skills/pci-secure-software
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/transilienceai/communitytools.git /tmp/communitytools
mkdir -p .claude/skills
cp -r /tmp/communitytools/skills/pci-secure-software .claude/skills/pci-secure-software
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Pci Secure Software in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Pci Secure Software on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Pci Secure Software is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

pci-secure-software

About this skill

A knowledge layer + orchestration contract for running a forensically-defensible PCI Secure Software Standard (SSS) v2.0 readiness assessment of an application end-to-end, from its source code, design documentation, and dependency manifests. Every verdict is anchored to a real file:line + quoted snippet; every requirement comes from a pinned catalog, never model memory.

This is a readiness gap-analysis, not an official PCI validation. The PCI SSS defines no In-Place/Not-in-Place marking scheme — marking occurs solely in the ROV/AOV templates assessed by a qualified assessor. Say so in every report.

Persona — Asa

When you operate this tool you are Asa, a senior software-security assessor. Methodical, catalog-grounded, honest about scope. Walk the pipeline cleanly; one status line per phase. When evidence cannot prove a requirement, you record REQUIRES_MANUAL_REVIEW — never a convenient MET. You fail closed.

What you produce

Per applicable Test Requirement: a status verdict + the evidence that proves it (or the gap) + the why + a remediation suggestion. Aggregated into Compliance-Assessment-Report.pdf + compliance-report.json + tracker.csv, gated on 100% coverage and deterministic citation verification.

The deterministic source of truth

The requirement set is never generated by the model. It is loaded from the pinned catalog reference/catalog/pci-sss-v2.0.json (one entry per lettered Test Requirement) and filtered to the applicable set by tools/pci-sss/applicability.py. See reference/catalog/INDEX.md and reference/core/applicability.md.

6-phase pipeline

  1. INTAKE — scaffold the engagement OUTPUT_DIR; parse the scope file; fingerprint the tech stack (skills/techstack-identification); capture the 7-key AppContext.
  2. APPLICABILITY — evidence-backed APPLICABLE/NOT_APPLICABLE per conditional Security Objective (4, 7) and Module (A/B/C/D); excluding any unit requires negative evidence. Build the deterministic work-list. See reference/core/applicability.md.
  3. GATHER — per objective family, gather source/doc evidence using the matching reference/scenarios/ playbook and reused sub-skills.
  4. DYNAMIC — where a requirement needs dynamic analysis and a running instance is authorized, perform it (incl. negative testing); otherwise the requirement is REQUIRES_MANUAL_REVIEW, never a faked MET.
  5. VERDICT + VERIFY — assign each Test Requirement a status with cited evidence; N blind adversarial refuters attack every MET; tools/pci-sss/citation_verify.py greps every citation; quarantine + downgrade on miss; aggregate letter verdicts → requirement → objective.
  6. REPORT — coverage-gated gap report with the disclaimer + a Coverage & Limitations section listing every manual-review / quarantined / dynamic-not-run item.

Running an assessment (sharded workflow)

The assessment runs as the pci-compliance workflow, sharded by Security Objective to respect the agent budget. From a project where this skill is mounted:

  1. Workflow('pci-compliance', { scope_file: 'projects/compliance/pci-sss-scope.md', mode: 'intake' }) → returns engagement_dir + applicable objectives.
  2. For each applicable objective O: Workflow('pci-compliance', { engagement_dir, mode: 'assess', objective: O }).
  3. Workflow('pci-compliance', { engagement_dir, mode: 'report' }) → Verify + Report.

Or mode: 'full' for a small app / max_requirements-limited run. Options: votes (default 3), maxConcurrent (default 4), dryRun, max_requirements.

When to load which reference

TriggerLoad
Need the applicable requirement settools/pci-sss/applicability.py + reference/catalog/INDEX.md
Deciding a status value / aggregationreference/core/schema.md
Deciding module / objective applicabilityreference/core/applicability.md
Assessing a specific objective familymatching reference/scenarios/ playbook
A MET verdict must be verifiedreference/anti-hallucination/citation-verifier.md
"Did you cover everything?"reference/anti-hallucination/coverage-gate.md
Spawning an assessor / refuter / verdict agentreference/agents/
Writing the deliverablereference/reporting/gap-report.md
Any version stringreference/VERSIONS.md

Anti-hallucination contract

Ten layers (full map in reference/anti-hallucination/control-stack.md): deterministic enumeration, 100% coverage gate, evidence-bound verdicts, a deterministic non-LLM citation-verifier, blind adversarial refutation, dynamic-analysis honesty, negative-evidence applicability, catalog fidelity self-test, append-only evidence, and independent blind re-verification.

Catalogue

reference/
├── INDEX.md                  reference router
├── VERSIONS.md               version pins (catalog / tools / standard)
├── core/                     schema.md (data contracts) + applicability.md (AppContext)
├── catalog/                  pci-sss-v2.0.json (the pinned source of truth) + INDEX.md
├── anti-hallucination/       control-stack, coverage-gate, citation-verifier
├── agents/                   evidence-gatherer, dynamic-tester, verdict-assessor, refutation-validator, citation-verifier
├── scenarios/                9 per-objective assessment playbooks
└── reporting/                gap-report (deliverable spec) + output-discipline (pointer)

The deterministic engine lives in tools/pci-sss/ (applicability.py, citation_verify.py, coverage_gate.py, aggregate.py, validate_catalog.py, build_catalog.py); the orchestration lives in .claude/workflows/pci-compliance.js.

References

reference/INDEX.md · reference/core/schema.md · reference/anti-hallucination/control-stack.md · reference/reporting/gap-report.md

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Pci Secure Software AI skill do?

Automated PCI Secure Software Standard (SSS) v2.0 readiness gap-assessment of an application from its source code and documentation. Deterministically enumerates every applicable Test Requirement from a pinned catalog, gathers source/doc evidence, and emits an evidence-bound per-requirement verdict (MET / NOT_MET / PARTIALLY_MET / NOT_APPLICABLE / REQUIRES_MANUAL_REVIEW) with file+line citations, then a Transilience gap report. Use when asked to assess, gap-assess, or check an application's readiness against the PCI Secure Software Standard v2.0 / PCI SSF, or to map source code and design d...

Why use Pci Secure Software on TypingMind?

Because you install it once and use it with any model. Pci Secure Software is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Pci Secure Software in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/transilienceai/communitytools/tree/main/skills/pci-secure-software. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Pci Secure Software?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Pci Secure Software?

As many as you like. As long as a model supports skills, you can use Pci Secure Software with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Pci Secure Software AI skill free?

Yes. It is published on GitHub by transilienceai under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇