guardrails

Run pre-flight and post-implementation self-review protocols for AI-generated code.

150|48|Updated Jan 24, 2026
One-click install
npx skills add https://github.com/irahardianto/awesome-agv --skill guardrails-irahardianto
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: guardrails
Source: https://github.com/irahardianto/awesome-agv/tree/main/.agents/skills/guardrails
Command: npx skills add https://github.com/irahardianto/awesome-agv --skill guardrails-irahardianto

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

It prevents AI-generated code from drifting off the project’s standards by enforcing a structured pre-flight checklist and a post-implementation self-review.

Core Features & Use Cases

  • Pre-Flight Checklist: ensures applicable rules are identified, patterns are searched, boundaries are defined, and conflicts are checked before writing code.
  • Post-Implementation Self-Review: verifies security, testability, observability, error handling, consistency, and language-specific correctness before verification.
  • Use Case: Before implementing a feature, run the pre-flight steps to confirm architecture and testing strategy; after implementing, run the self-review to ensure the change is safe, observable, and maintainable.

Quick Start

Use the guardrails skill at the start of the implement phase to run the pre-flight checklist, then again at the end of implementation to run the self-review before verification.

Frequently Asked Questions about guardrails

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I enforce code quality and security compliance for AI-generated code?

You enforce code quality and security compliance by running structured pre-flight checklists and post-implementation self-reviews. This validates architectural patterns, testing strategies, and universal security checks before and after code changes.

What is a pre-flight checklist for software implementation?

A pre-flight checklist is a protocol run before writing code to identify applicable rules, search architectural patterns, define boundaries, and check rule conflicts. It confirms architecture and testing strategy prior to implementation.

How do I validate testing strategy and observability before code verification?

You validate testing strategy and observability by running a post-implementation self-review. This enforces universal checks for testability and error handling, alongside loading optional language-specific checklists for active languages.

Does this guardrails protocol work for any programming language?

Yes, the protocol applies universal security and testability checks across all languages, while loading optional language-specific checklists only for the active implementation language to ensure correctness.

When should I run pre-flight and post-implementation code reviews?

Run pre-flight checklists at the start of the implementation phase to confirm architecture, and run post-implementation self-reviews at the end of coding to ensure changes are safe, observable, and maintainable before verification.