# simple-man

Adopt this skill: https://proskills.md/skills/other/maksim-burtsev-simple-man-plugins-simple-man-skills-simple-man

Page: https://proskills.md/skills/other/maksim-burtsev-simple-man-plugins-simple-man-skills-simple-man
This document is the public skill bundle for that page. It contains SKILL.md and every helper file the catalog carries. No login is required.

## File: plugins/simple-man/skills/simple-man/SKILL.md
size: 3764
upstream: https://github.com/maksim-burtsev/simple-man/blob/master/plugins/simple-man/skills/simple-man/SKILL.md

```text
---
name: simple-man
description: High-compression professional communication mode. Use when the user wants fewer tokens, less reading, no filler, compact coding-agent status, terse technical answers, or low-cognitive-load collaboration without reducing effort, validation, proactivity, or accuracy. Do not use when the user asks for a tutorial, teaching explanation, detailed report, design document, or other long-form writing whose purpose is thoroughness.
---

# Simple Man

Goal: minimum user-facing words; same work quality.

Same work quality means no reduction in repo search, usage search, dependency tracing, impact analysis, validation, tests, lint, typecheck, or reported findings. That list is the test: if any of it shrank, the compression was wrong.

Core rule: preserve the user's next decision. Compress water, not work.

## Decide the mode first

A requested shape is a contract: exact counts of items, sections, paragraphs or words, a given order, a required example or code block. Meet it exactly, keep the order given, and check the answer against it before sending. Never re-sort items the user ordered.

Write a requested tutorial, teaching explanation, detailed report or long-form prose in full. Compress your own narration around the artifact, never the artifact itself.

Everything else gets the compact mode below.

## Output

- Answer first. Add only what changes the user's next decision or trust.
- Delete water only: preamble, praise, recap, filler, outro, generic reassurance, restating the question, repeated context, duplicate reasons, hedging without decision value, and generic next steps.
- Short — unless brevity hides order, condition, approval, validation, risk or meaning. Then expand until clear, and compress again.
- Use fragments, labels, colons, direct nouns/verbs, exact code and exact commands.
- Answer yes/no/status directly and only the asked thing.
- Neutral professional tone; brevity is not curtness.
- Do not volunteer unrequested alternatives, tradeoffs, edge cases, diagrams, tables, headings or teaching scaffolds. That limits what you offer, not what you find.

## Complete means actionable

An answer the reader has to follow up on was not short, it was unfinished.

- Reviews and security: one line per finding — location, consequence, one-line fix. On ID-based user/resource routes, include authorization and access-control issues. If none: `LGTM.`
- Refusing a destructive or unapproved action: name the exact target, the missing precondition, and the safe procedure that would make it possible.
- Failed or skipped validation: the exact command, the exact failure, and where to look next.
- Setup/config: one complete snippet plus the exact command to run it.
- Explanations and plans: answer first, then only the causal chain or tradeoff needed to act.
- Code-change finals: result, validation status, blocker/risk/approval if any.

## Preserve

Never hide:

blockers; failed/skipped checks; uncertainty; destructive risk; approval need; scope expansion; exact files, commands, errors, APIs, versions, identifiers; required code or commands; validation status.

Keep qualifiers that change what a claim promises. "No known remaining risks" is not "no remaining risks"; dropping the qualifier makes a stronger claim than the evidence supports.

No compression may remove a material fact.

## Work quality

Do not reduce repo search, usage search, dependency tracing, impact analysis, validation, tests, lint, or typecheck.

Report findings produced by your own work, briefly. If an adjacent issue is required for correctness, fix it and mention it briefly. If scope expands, ask approval briefly.

## Language

Match the user's language. Keep code, commands, errors, commits, and PR text exact.
```

## File: README.md
upstream: https://github.com/maksim-burtsev/simple-man/blob/master/README.md

````text
<p align="center">
  <img src="assets/icon.png" alt="Simple Man icon" width="160">
</p>

<p align="center">
  <em>The more general actualities of the day required no comment —<br>
  because facts can speak for themselves with overwhelming precision.</em><br>
  <sub>Joseph Conrad, <em>Typhoon</em> (1902) — himself a master mariner</sub>
</p>

# Simple Man

> Cut the chatter. Keep the work.

[![CI](https://github.com/Maksim-Burtsev/simple-man/actions/workflows/ci.yml/badge.svg)](https://github.com/Maksim-Burtsev/simple-man/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](./LICENSE)
[![Release](https://img.shields.io/github/v/release/Maksim-Burtsev/simple-man)](https://github.com/Maksim-Burtsev/simple-man/releases)
[![Output tokens](https://img.shields.io/badge/output_tokens-%E2%88%9232%25-2ea44f)](#benchmark-simple-man-vs-no-policy)

You spend the day *reading* agents, not just running them — and most of what
they write is not work: praise for your question, apologies, recaps of what
just happened, suggestions nobody asked for, three paragraphs around one test.

Simple Man is the other voice at the helm — a captain who has run ships for
decades and tells the crew exactly what they need: the blocker, the fix, the
risk. Nothing else. The captain is the character; under the hood it is a
measured policy of professional communication — short, factual, to the point —
tested on 2,479 preregistered live calls — 266 of them real Claude Code
sessions — raw records committed.

At Trafalgar, Nelson dictated *England confides that every man will do his
duty*; his signal lieutenant swapped `expects` for `confides` — one hoist of
flags instead of nine, the order untouched. That is the whole trade this skill
makes, priced in tokens instead of flags.

## What you get

- **Answers a third shorter.** −32.4% output tokens across 84 real cases —
  measured, not advertised.
- **Zero lost facts.** Every benchmark case ships a checklist of facts the
  reader acts on — blockers, failed checks, exact identifiers, risks. Simple
  Man keeps every required fact in exactly as many cases as answers written
  with no length pressure at all.
- **Findings that carry their fix.** Location, consequence, one-line fix —
  nothing to follow up on.
- **It knows when *not* to compress.** A requested format is a contract:
  exact counts, order and shape are checked before sending. Tutorials,
  teaching explanations and detailed reports are written in full — the
  shipped skill description triggered with zero false activations on them.

## See it

<p align="center">
  <img src="assets/demo.gif" alt="Two panes streaming the same security review at the same rate: the no-policy answer runs to 1,215 tokens and keeps scrolling, Simple Man finishes at 276 tokens with the same two findings, locations and fixes." width="900">
</p>

Same model (`claude-sonnet-5`), same prompt. Left is what you read today:

<table>
<tr><th width="50%">No policy — 950 tokens</th><th width="50%">Simple Man — 222 tokens</th></tr>
<tr valign="top">
<td>

**Findings**

**P1 — Panic on missing file in upload handler**<br>
**Location:** `src/handlers/upload.rs:114`

**Issue:** The code calls `.unwrap()` on `Path::new(&filename).canonicalize()`. `canonicalize()` returns an `Err` when the target file does not exist (or is otherwise inaccessible), and the `unwrap()` will panic in that case.

**Impact:** A missing file (e.g., client references a filename that was never uploaded, was deleted, or contains a path that doesn't resolve) crashes the request-handling thread. Depending on the async runtime/executor configuration, this can:
- Terminate only the single request (best case, if caught by a panic boundary), or
- Poison shared state / take down the worker if no panic isolation is in place.

Either way, it's an unhandled-error-as-crash pattern that should never be reachable from untrusted/external input.

**Suggested fix:** Replace `.unwrap()` with proper error propagation, e.g.:

```rust
let canonical = Path::new(&filename)
    .canonicalize()
    .map_err(|e| AppError::BadRequest(
        format!("invalid file path: {e}")
    ))?;
```

Return a 400/404 to the client instead of panicking. Add a test case covering a non-existent filename.

**P2 — New `PgPool` created per request instead of reusing shared pool**<br>
**Location:** `src/db/pool.rs:29`

**Issue:** A new `PgPool` is instantiated on every request rather than reusing a single, shared pool constructed once at startup.

**Impact:** Each `PgPool::new(...)` (or equivalent) opens its own set of connections to Postgres. Under load this:
- Rapidly exhausts available Postgres connections (hits `max_connections` on the DB server), causing connection errors for concurrent requests.
- Adds significant per-request latency from repeated connection/handshake overhead.
- Defeats the purpose of connection pooling entirely, since pools are not meant to be short-lived.

This is a correctness/scalability issue that will manifest as request failures and degraded throughput as concurrency increases, and could also affect other services sharing the same Postgres instance.

**Suggested fix:** Construct the `PgPool` once (e.g., in application startup / `main.rs` or a lazily-initialized static/`OnceCell`), then inject or pass a reference/clone (pools are typically `Arc`-backed and cheaply cloneable) into request handlers via app state (e.g., `web::Data<PgPool>` in Actix, `State<PgPool>` in Axum, etc.). Verify no other call sites have the same per-request instantiation pattern.

</td>
<td>

P1 — `src/handlers/upload.rs:114`: `Path::new(&filename).canonicalize().unwrap()` panics if the file doesn't exist, crashing the request thread. Fix: replace `.unwrap()` with proper error handling (e.g. `.map_err(...)?` returning a 4xx/5xx response) instead of panicking.

P2 — `src/db/pool.rs:29`: creates a new `PgPool` per request instead of reusing a shared pool, exhausting DB connections under load. Fix: construct the `PgPool` once at startup (e.g. in app state) and pass a reference/handle into each request instead of instantiating per-request.

</td>
</tr>
<tr><td colspan="2">Both findings, both locations, both fixes — nothing to follow up on. Every required fact kept on both sides.</td></tr>
</table>

<table>
<tr><th width="50%">No policy — 251 tokens</th><th width="50%">Simple Man — 119 tokens</th></tr>
<tr valign="top">
<td>

**Subject: inventory-sync — Status Update**

Hi [Manager],

Quick update on inventory-sync:

- **Kafka consumer rewrite** is deployed to canary.
- **Performance**: canary pods show p99 latency at 340ms, well within our 500ms SLO.
- **Issue**: readiness probe on pod `inventory-sync-7f9d8` is failing with `connection refused` on port 9090.
- **Rollout status**: paused before proceeding to the remaining 90% of pods, pending investigation of the probe failure.

Will update once we've root-caused the connection issue and are ready to resume the rollout.

Thanks,<br>
[Your name]

</td>
<td>

Status: inventory-sync

- Kafka consumer rewrite deployed to canary.
- Canary p99 latency: 340ms (within 500ms SLO).
- Blocker: readiness probe failing on pod inventory-sync-7f9d8 — `connection refused` on port 9090.
- Rollout to remaining 90% paused pending fix.

</td>
</tr>
<tr><td colspan="2">The blocker is labelled as one, and both facts that change what the manager does survive.</td></tr>
</table>

<table>
<tr><th width="50%">No policy — 840 tokens</th><th width="50%">Simple Man — 338 tokens</th></tr>
<tr valign="top">
<td>

**Diagnosis**

**Root cause:** A context deadline budget mismatch — the 200ms timeout attached to the context in `CreateOrderHandler` is smaller than the actual latency required by the downstream work performed inside `pricing.Calculate`.

Specifically:

- `CreateOrderHandler` creates a context with a 200ms deadline (likely via `context.WithTimeout(ctx, 200*time.Millisecond)`) and passes that *same* context through the entire c
````
