PAI's Inline Verification Methods for ISC Criteria: A Complete Guide to Automated Software Standards

Personal AI Infrastructure (PAI) provides seven built-in verification methods that automatically validate Integrated Software Criteria (ISC) during the build-verify-learn cycle.

PAI's inline verification methods for ISC criteria ensure that every software standard is objectively tested rather than manually checked. In the danielmiessler/Personal_AI_Infrastructure repository, these methods are defined in the v3.0 release and enforced by the core algorithm. This guide explains each verification type, how they map to concrete tools, and where they live in the codebase.

What Are PAI's Inline Verification Methods for ISC Criteria?

PAI's inline verification methods for ISC criteria are explicit tags attached to every software requirement that dictate how the criterion should be automatically validated. According to the v3.0 release notes in Releases/v3.0/README.md (lines 284-285), the system defines seven built-in methods that cover command-line execution, automated testing, static analysis, browser automation, pattern matching, documentation review, and custom scripting.

Each ISC entry includes a verify field that references one of these methods. During the build loop, PAI's core algorithm extracts this field and dispatches the appropriate verification routine.

The Seven Built-In Verification Methods

PAI v3.0 ships with seven explicit verification methods. Each maps to a specific tool or execution environment.

CLI Verification

The CLI method executes shell commands and validates output against expected patterns. This is implemented for criteria requiring endpoint health checks or environment validation.

const iscCLI = {
  id: 1,
  severity: "CRITICAL",
  description: "API returns 200 on valid input",
  verify: "CLI",  // runs a curl command and checks the status code
};

Test Verification

The Test method invokes automated test suites such as Jest, PyTest, or similar frameworks. This handles unit and integration test validation.

const iscTest = {
  id: 2,
  severity: "CRITICAL",
  description: "Auth rejects expired tokens",
  verify: "Test",  // invokes `npm test` and expects a failure case
};

Static Verification

The Static method performs static analysis including linting, type checking, and security scanning without executing the code.

Browser Verification

The Browser method uses headless browser automation (Playwright) to verify UI behavior, component rendering, and user interaction flows.

const iscBrowser = {
  id: 4,
  severity: "MEDIUM",
  description: "Component renders loading state",
  verify: "Browser",  // launches Headless Chromium, checks DOM element presence
};

Grep Verification

The Grep method searches source files with pattern matching to enforce coding standards, such as prohibiting console.log statements in production code.

const iscGrep = {
  id: 3,
  severity: "HIGH",
  description: "No console.log in production code",
  verify: "Grep",  // runs `rg "console\\.log" src/` and must return 0 matches
};

Read Verification

The Read method confirms that documentation or manual artifacts exist and contain required content, such as ensuring a README documents all API endpoints.

const iscRead = {
  id: 5,
  severity: "LOW",
  description: "README documents all endpoints",
  verify: "Read",  // ensures `README.md` contains a table of endpoints
};

Custom Verification

The Custom method allows task-specific, user-defined verification routines with explicit steps for complex validation scenarios not covered by the built-in methods.

const iscCustom = {
  id: 6,
  severity: "CUSTOM",
  description: "Database schema matches design spec",
  verify: "Custom",  // runs `scripts/verify-schema.sh` and parses its JSON output
};

How Inline Verification Works in PAI's Core Algorithm

PAI's inline verification methods for ISC criteria are orchestrated by the core algorithm defined in skills/PAI/Algorithm.ts. During each build loop, the algorithm reads ISC front-matter, extracts the verify field, and dispatches the corresponding verification routine.

The dispatch mechanism is implemented in hooks/Verification.hook.ts, which maps the string value of the verify field (e.g., "CLI", "Browser") to concrete execution logic. For example, when the algorithm encounters verify: "Browser", the hook launches the Playwright-based headless browser environment and returns the pass/fail status.

Validation of the ISC criteria themselves occurs in tools/Validate-protected.ts, which ensures every criterion has an appropriate verification suffix before the build process begins.

Key Files and Architecture

Understanding PAI's inline verification methods for ISC criteria requires familiarity with these specific source files:

• Releases/v3.0/README.md (lines 284-285): Defines the seven built-in verification methods and provides the ISC examples shown in lines 245-250.
• hooks/Verification.hook.ts: Implements the runtime dispatch that maps verify suffixes to concrete verification routines.
• skills/PAI/Algorithm.ts: Core algorithm that reads ISC front-matter and orchestrates the verification rehearsal step.
• tools/Validate-protected.ts: Utility that validates ISC integrity, ensuring each criterion has a valid verification method assigned.

Summary

PAI's inline verification methods for ISC criteria provide automated, objective validation for every software standard in the Personal AI Infrastructure repository.

• Seven built-in methods cover the full verification spectrum: CLI, Test, Static, Browser, Grep, Read, and Custom.
• Explicit tagging via the verify field in ISC definitions ensures every criterion is testable.
• Core orchestration happens in skills/PAI/Algorithm.ts with dispatch logic in hooks/Verification.hook.ts.
• Validation occurs pre-build via tools/Validate-protected.ts to ensure method integrity.

Frequently Asked Questions

What does the Grep verification method check in PAI?

The Grep verification method performs pattern matching across source files to enforce coding standards. For example, it can verify that no console.log statements exist in production code by running rg "console\\.log" src/ and expecting zero matches. This method is defined in the v3.0 release notes and implemented via the verification hook dispatcher.

How does PAI's Algorithm.ts use the verify field?

The skills/PAI/Algorithm.ts file reads the front-matter of each ISC criterion and extracts the verify field to determine which validation routine to execute. During the build-verify-learn cycle, the algorithm passes this value to hooks/Verification.hook.ts, which maps the string (e.g., "Browser", "CLI") to the concrete tool or environment, executes the check, and returns the pass/fail status.

Can I create custom verification methods in PAI?

Yes, PAI supports Custom verification methods for criteria that require specialized validation beyond the six built-in options. You define a custom method by setting verify: "Custom" in the ISC definition and specifying the explicit steps or script to run, such as scripts/verify-schema.sh. The verification hook executes this custom routine and parses its output to determine compliance.

Where are the inline verification methods documented in the source code?

The inline verification methods are officially documented in Releases/v3.0/README.md at lines 284-285, which lists the seven methods (CLI, Test, Static, Browser, Grep, Read, Custom). Practical examples of ISC criteria using these methods appear at lines 245-250 of the same file. The implementation logic resides in hooks/Verification.hook.ts, while validation occurs in tools/Validate-protected.ts.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}