Skills DirectorySkills Directory
SkillsLearnSecurityCategoriesDocsCommunityBlog
Sign InSubmit Skill
Skills Directory

Security-tested agent skills for Claude, coding agents, and AI workflows.

Directory

  • Browse Skills
  • All Skills A–Z
  • Claude Skills
  • Claude Code Skills
  • Agent Skills
  • Categories
  • Submit a Skill

Learn

  • Learn Hub
  • Install Claude Skills
  • Write SKILL.md
  • Skills vs MCP
  • Directories Compared

Security

  • Security
  • Methodology
  • Secure Claude Skills
  • Security Badges

Company

  • About
  • Community
  • Blog
  • API Docs
  • Advertise

2026 Skills Directory. All rights reserved.

Back to skills

Anmath Methods

ASecurity

Use when laying out the proof strategy of a pure-mathematics manuscript for Annals of Mathematics — the architecture of the argument, the key lemmas and propositions, the novel technique, and where the difficulty lies. Designs and exposes the proof plan; does not check final correctness line-by-line (see anmath-referee-strategy).

16,300 stars
0 votes
0 copies
0 views
Added 9/19/2026
ai-agents

Security Analysis

A100/100

Scanned 9/19/2026

Install to Claude Code

$npx -y skills add tradecatlabs/vibe-coding-cn --skill anmath-methods --agent claude-code

Installs into .claude/skills of the current project.

Are you the author of Anmath Methods?

Add the live security badge to your README — it updates automatically with every re-scan.

Security grade badge for Anmath Methods
[![Security: A — Skills Directory](https://www.skillsdirectory.com/api/skills/tradecatlabs-anmath-methods/badge)](https://www.skillsdirectory.com/skills/tradecatlabs-anmath-methods)

More formats (shields.io, HTML) on the badges page.

Download Zip
Files
SKILL.md
---
name: anmath-methods
description: Use when laying out the proof strategy of a pure-mathematics manuscript for Annals of Mathematics — the architecture of the argument, the key lemmas and propositions, the novel technique, and where the difficulty lies. Designs and exposes the proof plan; does not check final correctness line-by-line (see anmath-referee-strategy).
---

# Proof Strategy and Architecture (anmath-methods)

## When to trigger

- The proof is essentially complete but its logical structure is not laid out for a reader
- A referee would not be able to see the plan before drowning in the details
- The key new idea is buried; it is not clear where the real difficulty is overcome
- The argument is monolithic and should be decomposed into named lemmas/propositions

## Architecture-first principle

For an Annals paper, an expert non-specialist should be able to read a **proof overview**
and understand *how* the theorem is proved before verifying *that* it is. The architecture
is part of the contribution.

1. **Proof outline up front.** After stating the Main Theorem, give a paragraph or short
   section sketching the strategy: the main steps, the key lemma(s), and the crux.
2. **Decompose into named results.** Break the argument into Lemmas, Propositions, and
   intermediate Theorems, each stated precisely and proved before it is used.
3. **Isolate the new idea.** Name explicitly which step is the genuinely new technique and
   why prior approaches failed there. This is what makes the paper publishable.
4. **Locate the difficulty.** Tell the reader where the hard part is and why it is hard;
   do not let the crux pass disguised as routine.

## Decomposition guidance

| Symptom | Action |
|---------|--------|
| A 10-page proof with no internal structure | Extract Lemmas/Propositions with clear statements |
| The same estimate reused three times | State it once as a Lemma and cite it |
| A self-contained technical computation interrupting the flow | Push to an appendix (anmath-supplementary) |
| Reliance on a deep external theorem | State it precisely with citation; do not paraphrase loosely |
| The crux step stated as "a calculation shows" | Expand fully — this is exactly what referees check |

## Handling the key technique

- State the **novel ingredient** as its own result when possible (a key Lemma or
  Proposition), so others can cite and reuse it — methods with reach justify Annals.
- Contrast with the **standard approach**: one or two sentences on why the obvious method
  does not work and how the new idea circumvents the obstruction.
- If the method is borrowed and adapted, **attribute it** and state precisely what is new
  in your adaptation.

## Dependence on external results

- Every external theorem you invoke must be **published and precisely cited**; quote the
  exact statement you use, not a vague version.
- Do **not** build an essential step on an unpublished or unverifiable claim; if
  unavoidable, isolate the dependence and flag it explicitly.

## Checklist

- [ ] A proof overview appears before the detailed argument
- [ ] The argument is decomposed into precisely stated lemmas/propositions
- [ ] Each auxiliary result is proved before it is used
- [ ] The genuinely new idea is named and explained as the crux
- [ ] Why the standard approach fails is stated explicitly
- [ ] Every external result invoked is published and precisely cited
- [ ] No essential step rests on an unpublished/unverifiable claim
- [ ] The crux is proved in full, not waved through as "a calculation"

## Anti-patterns

- A monolithic proof with no roadmap — the referee cannot navigate it
- Hiding the crux inside a step labeled "routine" or "standard"
- Restating a known method as if it were new without attribution
- Paraphrasing an external theorem loosely so the actual hypothesis is unclear
- Reusing the same estimate inline three times instead of stating it once
- Leaving the reader unable to say where the difficulty was overcome

## Output format

```
【Proof strategy, one paragraph】...
【Key lemmas/propositions】L1: ...; P1: ...; ...
【The new idea (crux)】...
【Why the standard approach fails】...
【External results relied on】author (year), Thm X — exact statement used
【Steps to push to appendix】... → anmath-supplementary
【Next step】anmath-figures (exposition & structure)
```

Attribution

tradecatlabstradecatlabs
View sourceMore from tradecatlabs →
SSkills DirectorySkills Directory

Ship a skill? Prove it's safe.

Free 120-pattern security scan, letter grade, and an embeddable README badge.

Submit a skill

Is this your skill, or is something wrong with this listing? Request removal or report an issue. Author removals are honored within 72 hours.

Comments (0)

No comments yet. Be the first to comment!

SSkills DirectorySkills Directory

Ship a skill? Prove it's safe.

Free 120-pattern security scan, letter grade, and an embeddable README badge.

Submit a skill

Related Skills

Caveman

Ultra-compressed communication mode. Cuts token usage ~75% by speaking like caveman while keeping full technical accuracy. Supports intensity levels: lite, full (default), ultra, wenyan-lite, wenyan-full, wenyan-ultra. Use when user says "caveman mode", "talk like caveman", "use caveman", "less tokens", "be brief", or invokes /caveman. Also auto-triggers when token efficiency is requested.

1023331 votes

Hyperplan

Adversarial multi-agent planning skill. Self-orchestrates 5 hostile category members (unspecified-low, unspecified-high, deep, ultrabrain, artistry) via team-mode for ruthless cross-critique debate, distills only the defensible insights, then MANDATORILY hands the distilled insight bundle to the `plan` agent for executable plan formalization. Use when planning needs maximum rigor and surfacing of weak assumptions, blind spots, and over-engineering. Triggers: 'hyperplan', 'hpp', '/hyperplan', ...

686011 votes

Mcp Code Execution

Routes multi-tool workflows through MCP servers for large datasets and pipelines. Use when Bash tool overhead is limiting throughput on data-heavy tasks.

3331 votes

catchup

Recovers prior coding-agent session context by running `catchup <agent> --since-compact`, which extracts a clean summary of a previous Codex, Claude Code, Antigravity, OpenCode, or Pi Agent session. Use when the user says "catch up", "what did the last session do", "get me up to speed", "I switched agents", or asks to recover/summarize a previous session before continuing. Do NOT use for the current conversation, git history, or any non-agent log.

611 votes

math-skill

A comprehensive mathematical reasoning skill for AI assistants — handles arithmetic to research-level problems with rigorous step-by-step reasoning, systematic verification, and transparent uncertainty handling

381 votes
View all in ai-agents →