tim-e2e

The Trust Inspect Model (TIM)

A note from Tim Schreyack

I spent the first half of my career as a network engineer, building infrastructure on protocols like TCP/IP—where the fundamental challenge is creating something reliable on top of something unreliable. That mental model became second nature: you don't trust the underlying layer, you verify, you implement checksums, you build in retransmission. Reliability emerges from disciplined enforcement, not wishful thinking.

The second half of my career shifted to DevOps and network automation at companies like Network to Code, where I now work as Director of Sales Engineering. My mode of operation became: if there's a manual process, write code to automate it. If there's a repeatable workflow, make it repeatable reliably.

When I started using Claude Code and discovered Boris Cherny's workflow—the plan-first approach, iterating until the plan is right, then executing—I immediately thought: how do I automate this and get reliable results? AI is like IP: powerful but unreliable. It hallucinates, it stops early, it makes excuses. The TIM standards are my TCP: verification loops, enforcement gates, and tooling that makes reliability emerge from an unreliable substrate.

Is this perfect? No. Can it use improvement? Absolutely. Please submit PRs as you use the code—this is a living project that gets better with real-world usage.

— Tim Schreyack (LinkedIn)

---

The Trust Inspect Model (TIM) is a set of design standards for AI-driven software development.

The Problem

AI agents write plausible-looking code that compiles and runs, but silently introduces bugs, security holes, and incomplete implementations. Traditional coding standards fail because they rely on human discipline—AI agents will take shortcuts, make excuses, and declare "done" prematurely unless physically prevented from doing so.

The Philosophy

The TIM standards enforce a Plan → Review → Code → Verify → Test → Deploy lifecycle where humans approve plans and deployments, AI executes in between. This keeps humans in control of "what" and "when" while AI handles "how." Every phase has gates that block progression until requirements are met.

The core principle: if a rule can be bypassed, an AI will bypass it—so the TIM standards remove the bypass.

The Enforcement

The TIM standards solve this through automated enforcement at every layer:

• Pre-commit hooks block commits that fail type checking or contain secrets
• CI pipelines block merges when tests fail, report coverage for reviewers
• Deploy gates require human approval before production
• Real-time behavioral hooks catch AI making excuses or writing oversized files
• Tim Loop re-injects task prompts until verification passes—there is no "good enough," only 100% complete

What You Get

A complete enforcement framework:

• Standards documentation for coding, testing, security, and deployment
• Ready-to-copy templates for CI pipelines, pre-commit hooks, and configuration
• Shared libraries (tim-lib for Python, @tim/lib for Node.js, tim-common.sh for Bash)
• Tim Loop plugin for guaranteed task completion with AI behavioral enforcement
• Tim PBT plugin for property-based bug hunting with Hypothesis/fast-check
• Tim E2E plugin for Playwright MCP-driven end-to-end testing
• The plan-ops CLI for human-gated plan management
• Enforcement tools: compliance checker, settings SOT enforcement

Adopt the full framework for new projects, or install Tim Loop standalone for immediate benefit.

Quick Navigation

I want to...	Go here
Install Tim Loop now	Just Want Tim Loop?
Understand when to use what	Choosing Your Workflow
See a complete example	Recommended Workflow
Set up a full TIM project	New Project Setup
Browse all standards	Standards Index
Hunt bugs with PBT	Tim PBT
Generate E2E tests	Tim E2E

The Tools

Tim Loop is a Claude Code plugin that enforces the TIM standards' most critical requirement: tasks must be 100% complete, not "mostly done." It captures the original task, loops until all objectives are verified complete, preserves context when conversations get too long, enforces code quality limits in real-time, and blocks completion when AI tries to make excuses. The loop continues until verification passes—there is no early exit.