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

> Explore PAI's inline verification methods for automated ISC criteria checks. Learn how PAI validates software standards during the build-verify-learn cycle in this comprehensive guide.

- Repository: [Daniel Miessler 🛡️/Personal_AI_Infrastructure](https://github.com/danielmiessler/personal_ai_infrastructure)
- Tags: how-to-guide
- Published: 2026-02-16

---

**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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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.

```typescript
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.

```typescript
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.

```typescript
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.

```typescript
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.

```typescript
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.

```typescript
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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/hooks/Verification.hook.ts)**: Implements the runtime dispatch that maps `verify` suffixes to concrete verification routines.
- **[`skills/PAI/Algorithm.ts`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/skills/PAI/Algorithm.ts)**: Core algorithm that reads ISC front-matter and orchestrates the verification rehearsal step.
- **[`tools/Validate-protected.ts`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/skills/PAI/Algorithm.ts) with dispatch logic in [`hooks/Verification.hook.ts`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/hooks/Verification.hook.ts).
- **Validation** occurs pre-build via [`tools/Validate-protected.ts`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/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`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/hooks/Verification.hook.ts), while validation occurs in [`tools/Validate-protected.ts`](https://github.com/danielmiessler/Personal_AI_Infrastructure/blob/main/tools/Validate-protected.ts).