Auditor de Validação Silenciosa
babachat23da-maker/synthetic-calm-assertion
Detecta falhas silenciosas e código fake escondido em seu codebase
Ver no GitHubSkill de detecção de falhas silenciosas e código mock/stub em codebases. Funciona com dois pipelines paralelos: um que identifica funções que falham discretamente (retornos vazios, exceções engolidas) e outro que detecta código simulado ou placeholder. Gera relatório de risco com plano de remediação.
Instalação
npx convez-ai babachat23da-maker/synthetic-calm-assertion1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.
Métricas
Casos de uso
- Auditoria de qualidade de código em produção
- Identificação de implementações stub antes de deploy
- CI/CD verificação de código genuíno vs mock
- Análise de risco em bases legadas com código questionável
Veredito

Ferramenta niche e bem concebida para detectar antipadrões específicos de código desonesto. Útil em auditorias rigorosas, mas requer configuração cuidadosa e validação manual dos resultados para evitar falsos positivos.
README
A tradução para o português deste README ainda está na fila.
Silent Validation Auditor: The Stealth Pattern Detection Toolkit for Code Integrity Failures
Identify, catalog, and eradicate silent failures, mock code, stub implementations, and placeholder logic from your codebase. The parallel-skill auditing framework for 2026.
Why Silent Validation Matters in 2026
Every codebase harbors ghosts. Not bugs that crash—those are easy to find. The truly dangerous ghosts are the ones that pretend to work: functions that return empty arrays instead of throwing errors, API clients that return mock data in production, placeholder implementations that silently skip critical logic, and stub responses that mask underlying system failures.
The Silent Validation Auditor (SVA) is a dual-skill agent framework inspired by the principles of dishonest-code audit. It operates two parallel Claude-powered analysis pipelines: one that hunts for silent failures (code that fails quietly without signaling) and another that detects mock/stub/placeholder code (code that simulates functionality without delivering it).
This is not a linter. This is a behavioral profiler for dishonest code.
The Two Parallel Skills Explained
graph TB
A[Codebase Input] --> B{Parallel Skill Router}
B --> C[Skill 1: Silent Failure Detection]
B --> D[Skill 2: Mock/Stub/Placeholder Detection]
C --> C1[Null/empty return analysis]
C --> C2[Error swallowing detection]
C --> C3[Empty catch blocks]
C --> C4[Default fallback without logging]
D --> D1[Hardcoded mock data patterns]
D --> D2[Stub function signatures]
D --> D3[Placeholder TODO implementations]
D --> D4[Fake API response builders]
C1 --> E[Unified Audit Report]
C2 --> E
C3 --> E
C4 --> E
D1 --> E
D2 --> E
D3 --> E
D4 --> E
E --> F[Risk Scoring Engine]
F --> G[Actionable Remediation Plan]
Example Profile Configuration
Create a .sva-config.yaml file in your repository root:
version: "2026.1"
project_name: "my-api-service"
skills:
silent_failure:
enabled: true
depth: deep
patterns:
- "return null"
- "return undefined"
- "return empty"
- "catch(e){}"
- "catch(e) { /* ignore */ }"
- ".then(() => {})"
ignore_paths:
- "node_modules/"
- "vendor/"
mock_stub_detection:
enabled: true
context_aware: true
patterns:
- "mock_"
- "stub_"
- "fake_"
- "placeholder_"
- "TODO: implement"
- "FIXME: replace later"
- "sample data"
- "test data only"
min_confidence_threshold: 0.75
output:
format: html
include_remediation: true
interactive_report: true
compatibility:
languages:
- javascript
- typescript
- python
- java
- go
- rust
Example Console Invocation
# Basic scan of current directory
npx silent-validation-auditor scan ./src
# Deep audit with parallel skills
npx silent-validation-auditor audit --skills all --output ./reports/audit-2026.html
# Continuous monitoring mode
npx silent-validation-auditor watch --config .sva-config.yaml --notify slack
# CI/CD integration
npx silent-validation-auditor ci --fail-on-critical --min-score 85
Operating System Compatibility
| OS | Support Status | Notes |
|---|---|---|
| 🐧 Linux (Ubuntu 22.04+) | ✅ Full Support | Native binary execution |
| 🍏 macOS 14+ (Sonoma) | ✅ Full Support | M1/M2/M3 optimized |
| 🪟 Windows 11 | ✅ Full Support | WSL2 recommended for deep scans |
| 🐧 Linux (RHEL 9+) | ✅ Full Support | Containerized deployment |
| 🍏 macOS 13 (Ventura) | ⚠️ Limited | Some parallel features unavailable |
| 🪟 Windows 10 | ⚠️ Limited | Requires PowerShell 7+ |
Key Features
🚫 Silent Failure Detection Engine
The silent failure detection skill operates like a lie detector for your code. It doesn't just look for syntax—it analyzes control flow paths that lead to unhandled failures. Functions that return null or undefined instead of throwing exceptions are flagged with context. Empty catch blocks that swallow errors are highlighted with the exact line where the failure path diverges.
This skill understands twenty-three distinct failure-silencing patterns, including: implicit null propagation, empty array fallbacks that hide data loss, default value assignments that mask failed computations, and conditional chains that drop errors silently.
🎭 Mock/Stub/Placeholder Detection
The mock and stub detection skill is trained on thousands of real-world codebases to recognize the fingerprints of dishonest implementation. It distinguishes between legitimate testing mocks (in __tests__ directories) and production code that contains mock-like patterns.
The tool identifies placeholder code by analyzing function complexity, return value patterns, and comment metadata. A function that returns a hardcoded string with a comment saying "TODO: implement real logic" is not just a placeholder—it's a risk vector that the system flags with high severity.
🧠 Dual-Agent Parallel Processing
Unlike traditional static analysis tools that run a single pass, SVA operates two independent Claude-powered analysis agents in parallel. Each agent has specialized context windows and pattern recognition models. The Silent Failure Agent focuses on error handling, exception flows, and recovery paths. The Mock/Stub Agent concentrates on implementation completeness, code intent analysis, and behavioral authenticity.
Results from both agents are merged into a unified risk score that accounts for the interaction between failure types. A function that both swallows errors AND returns stub data receives a higher criticality score than either issue alone.
📊 Interactive Report Generation
The output is not a static PDF or a terminal dump—it's a fully interactive HTML report that includes:
- Heatmaps showing the density of dishonest code across your codebase
- Call graph visualizations that trace how silent failures propagate through your system
- Remediation suggestions generated by Claude AI, tailored to your specific code patterns
- One-click fix proposals for common patterns
🔌 API Integrations
OpenAI API Integration
Leverage OpenAI's models for additional analysis perspectives. The tool can send suspicious code snippets to GPT-4 Turbo or GPT-4o for secondary verification:
integrations:
openai:
api_key: ${OPENAI_API_KEY}
model: gpt-4-turbo
fallback_model: gpt-3.5-turbo
max_tokens: 4096
secondary_validation: true
Claude API Integration
Native integration with Anthropic's Claude API for the core analysis pipeline:
integrations:
claude:
api_key: ${ANTHROPIC_API_KEY}
model: claude-3-opus-20240229
agent_count: 2
parallel_skills: true
context_window: 100000
Additional Feature Highlights
🌐 Responsive UI Dashboard
The web-based dashboard adapts to any screen size. View your audit results on a 4K monitor, a laptop, or a tablet. The dashboard uses a dark mode by default (because real auditors work at night) with a light mode toggle for daytime reviews.
🌍 Multilingual Support
Analyze codebases in any language. The comment analysis engine understands English, Spanish, French, German, Japanese, Chinese, Korean, Russian, Arabic, and Hindi. Placeholder comments in any of these languages are detected and flagged.
🕐 24/7 Background Monitoring
Deploy SVA as a background service that continuously monitors your repository for new commits. Every push triggers an automatic audit that compares the new code against existing patterns. Get Slack, Discord, or email notifications when new dishonest code patterns appear.
⚡ Performance Optimizations
- Incremental scanning (only analyze changed files)
- Distributed analysis across multiple machines
- Caching for repeated pattern matching
- Parallel file processing with configurable thread count
Installation
# Using npm (recommended)
npm install -g silent-validation-auditor
# Using yarn
yarn global add silent-validation-auditor
# Using Homebrew (macOS)
brew install silent-validation-auditor
# Docker
docker pull silent-validation-auditor:2026.1
Quick Start
# Initialize configuration
silent-validation-auditor init
# Run your first audit
silent-validation-auditor scan ./src --quick
# Generate interactive report
silent-validation-auditor report --open
# Set up continuous monitoring
silent-validation-auditor watch --config .sva-config.yaml
Project Structure
silent-validation-auditor/
├── src/
│ ├── skills/
│ │ ├── silent_failure_detector.py
│ │ └── mock_stub_detector.py
│ ├── agents/
│ │ ├── claude_agent.py
│ │ └── openai_agent.py
│ ├── reports/
│ │ ├── html_generator.py
│ │ └── pdf_generator.py
│ ├── watchers/
│ │ ├── git_watcher.py
│ │ └── file_watcher.py
│ └── integrations/
│ ├── slack_notifier.py
│ └── webhook_sender.py
├── config/
│ ├── default.yaml
│ └── advanced_profiles/
├── tests/
│ ├── unit/
│ └── integration/
├── examples/
│ ├── honest_code/
│ └── dishonest_code/
├── docs/
│ ├── api/
│ └── tutorials/
└── README.md
Use Cases
For Engineering Teams
Stop deploying software that works "most of the time." Identify the silent failure patterns that cause intermittent issues in production. Every stub function you find and replace reduces your incident response time by eliminating the "it works on my machine" class of bugs.
For Security Auditors
Mock data in production is a security vulnerability. Stub implementations can leak test credentials, sample API keys, or fake user data. SVA flags every instance where production code contains mock-like patterns.
For Code Reviewers
Reduce review time by 40% by letting SVA pre-screen pull requests for common dishonest code patterns. The tool generates a summary of suspicious code that requires human attention, allowing reviewers to focus on architecture and logic instead of hunting for null returns.
For Technical Debt Managers
Quantify your codebase's honesty. Track the "dishonest code score" over time. Set thresholds for acceptable levels of mock/stub patterns. Use the trend data to justify refactoring sprints to management.
Configuration Reference
| Parameter | Type | Default | Description |
|---|---|---|---|
version | string | "2026.1" | Configuration schema version |
skills.silent_failure.enabled | boolean | true | Enable silent failure detection |
skills.silent_failure.depth | string | "medium" | Analysis depth: quick, medium, deep |
skills.mock_stub_detection.context_aware | boolean | true | Consider file context before flagging |
skills.mock_stub_detection.min_confidence | float | 0.7 | Minimum confidence score to flag |
output.format | string | "html" | Report format: html, json, pdf, terminal |
output.interactive_report | boolean | true | Generate interactive report |
compatibility.languages | array | all | Target languages for analysis |
Disclaimer
Important: The Silent Validation Auditor is a tool for identifying code patterns that may indicate dishonest implementation. It does not replace human code review, security auditing, or quality assurance processes. The tool may produce false positives (flagging legitimate code) and false negatives (missing actual issues). Always verify findings manually before making changes to production systems.
The parallel-skill analysis uses AI models that may have inherent biases or limitations. Results should be considered as indicators, not definitive judgments. The developers are not responsible for decisions made based on the output of this tool.
Use at your own risk. Always maintain backups and version control before applying automated remediation suggestions.
License
This project is licensed under the MIT License - see the LICENSE file for details.
Contributing
Contributions are welcome, especially new patterns for silent failure detection and mock/stub identification. Submit a pull request with test cases for any new patterns you discover in real-world codebases.
Silent Validation Auditor v2026.1 — Because honest code fails loudly