Tools on Mikhail Shogin

AI Agent Linter Ecosystem: Quality, Cost and Safety Control

Tue, 24 Mar 2026 00:00:00 +0000

The Problem

AI agents write code fast, but speed comes at a cost. Literally - tokens cost money. And figuratively - code quality degrades without oversight.

I hit three problems at once:

Architecture degrades - agents write working code that violates layer boundaries, creates circular dependencies and god classes
Costs grow - complex prompts go to Opus at $15/1M tokens when Haiku at $0.80 would suffice
Content isn’t filtered - production prompts contain things that shouldn’t be there

Each problem has its own tool. But when the tools work together, they amplify each other.

The Pipeline

Every request passes through a chain of linters, each responsible for its domain:

seclint - checks content safety (6+/12+/16+/18+ ratings)
promptlint - scores complexity, picks the model
Agent - executes the task on the selected model
archlint - validates the result for architecture violations
costlint - records cost, tracks cache hit rate

If archlint rejects the result, the task escalates to a more powerful model. costlint records the escalation cost.

The Tools

archlint - Architecture Linter

Scans Go projects for structural violations.

1

archlint scan --format json ./project/

What it finds:

Layer violations (handler calls repository directly)
God classes (>20 methods or >15 dependencies)
Circular dependencies
Interface Segregation violations (interfaces >5 methods)

Metrics: fan-out, coupling (Ca/Ce), component and link counts.

GitHub: mshogin/archlint

promptlint - Complexity-Based Router

Scores prompt complexity and picks the model. No LLM, pure metrics, <10ms.

1
2
3
4
5


echo "Fix typo in README" | promptlint analyze --output-model
# haiku

echo "Design microservices with CQRS" | promptlint analyze --output-model
# opus

Signals: length, sentence count, domain keywords, action type (fix/create/refactor), code presence.

Integrates with ccproxy for real Claude Code request routing through a proxy.

GitHub: mikeshogin/promptlint

costlint - Token Cost Analysis

Tracks spending, analyzes caching, runs A/B tests between models.

1

costlint report --source telemetry.jsonl

1
2
3
4
5
6
7


Cost Report:
 Total requests: 342
 By model:
 opus: 48 requests, ~$12.60
 sonnet: 195 requests, ~$6.50
 haiku: 99 requests, ~$0.44
 With optimal routing: ~$8.20 (savings: 58%)

Cache metrics: hit rate, block reuse, content entropy, Jaccard similarity. A/B testing: 30/30/40 traffic split, per-group cost and quality metrics.

GitHub: mikeshogin/costlint

seclint / promptsec - Content Filter

Age ratings for prompts: 6+, 12+, 16+, 18+.

1
2
3
4
5


echo "Help with math homework" | seclint rate
# {"rating": "6+", "safe": true}

echo "Explain SQL injection for security course" | seclint rate
# {"rating": "16+", "safe": true, "flags": ["security_tools"]}

Considers educational context - explaining SQL injection for a security course gets 16+ instead of 18+.

GitHub: mikeshogin/seclint / mikeshogin/promptsec

Shared Principles

All tools follow the same rules:

Go - single stack, single build
No LLM - pure metrics, regex, keyword matching. <10ms per request
CLI + HTTP - each tool works as a command and as a server
JSONL telemetry - unified log format for analysis
Pipeline-friendly - exit codes, stdout, pipes

Numbers

On test workload (342 requests over a week):

Metric	Before	After
Token spending	$19.54	$8.20
Architecture violations	63	12
Requests to expensive model	100% opus	14% opus
Routing latency	-	<10ms

58% cost savings without quality loss - simple tasks go to Haiku, architecture tasks stay on Opus.

Orchestration

The tools work autonomously, but deliver maximum impact together. For orchestration we use myhome - daemon-based AI agent management with workflow stages and scheduled tasks.

The stack:

myhome launches agents
promptlint picks the model (pre-route hook)
archlint validates output (quality gate stage)
costlint tracks cost (telemetry consumer)
seclint filters incoming prompts (pre-filter)

Get Started

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15


# Install all tools
go install github.com/mshogin/archlint@latest
go install github.com/mikeshogin/promptlint/cmd/promptlint@latest
go install github.com/mikeshogin/costlint/cmd/costlint@latest
go install github.com/mikeshogin/seclint/cmd/seclint@latest

# Start routing
promptlint serve 8090 &
seclint serve 8091 &

# Check architecture
archlint scan --format json ./my-project/

# View costs
costlint report --source ~/.promptlint/telemetry.jsonl

$HOME in Git: One Config for Claude Code

Fri, 09 Jan 2026 00:00:00 +0000

Multiple projects. Each with its own CLAUDE.md, its own rules. You improve something in one place - you want it elsewhere. Copy. Improve there. Copy back. Round and round.

At some point I had a mess of different versions of the same rules scattered across a dozen projects. The copy-paste circus was annoying, but I kept putting it off.

During the New Year holidays, I decided to fix it.

The Solution

Moved everything to my home directory ~/.claude/. One config for all projects.

Yes, I’m now coupled to my home directory structure. But that structure hasn’t changed in years - ~/my/ for projects, ~/education/ for learning, ~/family/ for family stuff. Risk is minimal.

Structure

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


~/.claude/
 CLAUDE.md # Core principles (task confirmation, formatting)
 HOME_MAP.md # Home directory map for navigation

 rules/ # Rules (auto-loaded)
 architecture.md # Architecture principles
 coaching-layer.md # Coaching questions
 text-dna.md # Writing style
 home-navigation.md # Context detection by keywords
 projects/ # Project-specific rules
 aitrader.md # Rules for aitrader

 commands/ # Slash commands
 ms-todos.md # /ms-todos - task list
 ms-add-note.md # /ms-add-note - add note
 ...

 skills/ # Skills
 blog-writing/ # Blog post writing
 go-review/ # Go code review
 social-content/ # Social media content

 agents/ # Custom agents
 go-reviewer.md # Go code reviewer

 hooks/ # Hooks
 session-logger.py # Session logging

The key file is HOME_MAP.md. It’s a map of the entire home directory with context detection rules.

Claude sees keywords in your request and knows which directory to work in:

aitrader, archlint, blog -> ~/my/
course, book, learning -> ~/education/
memory, remember, mission -> ~/my/org-roam/

If context is ambiguous - it asks.

Project-Specific Rules

Need specific rules for a project? Add them to rules/projects/. For example, aitrader.md contains:

How to run the collector (without proxy for Tinkoff API)
Test commands
Project specifics

These rules load globally but apply only when working in the aitrader context.

Git

Everything under git. One repository, one history.

.gitignore is large - it excludes almost everything that shouldn’t be versioned: credentials, caches, Downloads, Documents, Library, .ssh. But everything else - configs, .claude/, dotfiles - is tracked. Planning to add private repos as submodules, so one git clone restores the entire home directory.

No more copying between projects. Improve a rule once - it works everywhere.

Result

Before: a dozen projects with scattered CLAUDE.md files, constant copying, different versions of the same thing.

After: one ~/.claude/, structured rules, git for versioning. Improve once - works everywhere.

Downside: tight coupling to home directory structure. For me it’s not a problem - the structure is stable.