New: 98,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Agent skill

Verified Pseudocode Extractor

by ArabelaTso in ArabelaTso/Skills-4-SE

Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic.

Apache-2.0Auto-check passedWriting & Content

Install Verified Pseudocode Extractor

skills CLI
$ npx skills add ArabelaTso/Skills-4-SE --skill verified-pseudocode-extractor -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install ArabelaTso/Skills-4-SE verified-pseudocode-extractor --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/ArabelaTso/Skills-4-SE.git skills-src && mkdir -p .claude/skills && cp -r skills-src/skills/verified-pseudocode-extractor .claude/skills/verified-pseudocode-extractor && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
verified-pseudocode-extractor
GitHub stars
253
Token cost
~2k tokens
SKILL.md length
513 words
Files
3 (incl. references)
Skills in repo
150
Repo updated
First seen
Licence
Apache-2.0

At a glance

Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic.

  • Works in 5 steps: Identify Verified Components → Extract Core Algorithm → Extract Verification Annotations → …
  • Users have verified code and need readable pseudocode
  • SKILL.md covers Core Principles, Workflow, Extraction Patterns and Verification Annotations, plus 5 more sections
  • Instructions only: no scripts, shell commands, URLs or credentials in SKILL.md

What it does

Verified Pseudocode Extractor is an agent skill from ArabelaTso/Skills-4-SE. Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic. Use when: (1) Users have verified code and need readable pseudocode, (2) Documenting verified algorithms for broader audiences, (3) Translating verified implementations to other languages, (4) Creating algorithm specifications from verified code, (5) Preserving verification guarantees in pseudocode form, or (6) Abstracting proof-heavy code to…

Its SKILL.md is about 2k tokens, which your agent loads only when the skill is triggered. The skill folder holds 3 other files, including reference files (for example `references/examples.md` and `references/extraction_patterns.md`).

It sits in Writing & Content, covering Translation. The repository describes itself as: A curated list of 180+ useful Claude Skills for Software Engineering and resources for customizing AI for SE workflows. The licence is Apache-2.0.

When your agent uses it

  • Users have verified code and need readable pseudocode
  • Documenting verified algorithms for broader audiences
  • Translating verified implementations to other languages
  • Creating algorithm specifications from verified code

Example prompts

  • “/verified-pseudocode-extractor”

Workflow steps

5 steps, taken from the step headings in SKILL.md.

  1. Identify Verified Components
  2. Extract Core Algorithm
  3. Extract Verification Annotations
  4. Structure the Pseudocode
  5. Verify Semantic Equivalence

What it can do on your machine

Read from SKILL.md and the folder at commit 4f38503. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are isabelle and coq).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

Verified Pseudocode Extractor loads about 2k tokens when it runs, and up to ~7k if it reads all its reference files. Until then it costs about 156 tokens; SKILL.md has 513 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~156
When it runs · the whole SKILL.md, loaded when a task matches
~2k
With references · SKILL.md plus every file in references/, read only if the agent opens them
~7k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from ArabelaTso/Skills-4-SE at commit 4f38503, republished under its Apache-2.0 licence (© ArabelaTso). 513 words, ~2,015 tokens.

Download SKILL.mdSave it as .claude/skills/verified-pseudocode-extractor/SKILL.md (or your agent's skills folder). This skill also uses 2 other files; get the full folder from GitHub.
name
verified-pseudocode-extractor
description
Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic. Use when: (1) Users have verified code and need readable pseudocode, (2) Documenting verified algorithms for broader audiences, (3) Translating verified implementations to other languages, (4) Creating algorithm specifications from verified code, (5) Preserving verification guarantees in pseudocode form, or (6) Abstracting proof-heavy code to essential logic. Maintains semantic faithfulness to verified implementation.

Verified Pseudocode Extractor

Extract language-agnostic pseudocode from formally verified programs while preserving verified properties and algorithmic structure.

Core Principles

Semantic Faithfulness
  • Preserve exact control flow from verified code
  • Maintain all data dependencies
  • Keep algorithmic logic intact
  • Do not introduce new behavior
  • Do not omit verified steps
Verification Preservation
  • Mark verified properties explicitly
  • Retain preconditions and postconditions
  • Include loop invariants
  • Note termination arguments
  • Distinguish verified from unverified components
Abstraction Without Loss
  • Remove language-specific syntax
  • Remove proof-specific code
  • Keep essential algorithmic structure
  • Maintain readability
  • Preserve correctness guarantees

Workflow

1. Identify Verified Components

Scan the input code for:

  • Function definitions: fun, Fixpoint, Definition
  • Theorems: lemma, theorem, Theorem, Lemma
  • Specifications: assumes/shows, preconditions/postconditions
  • Invariants: Loop invariants, inductive invariants
  • Helper lemmas: Supporting correctness proofs
2. Extract Core Algorithm

For each verified function:

Preserve:

  • Function signature (name, parameters, return type)
  • Control flow (if/then/else, pattern matching, recursion)
  • Data flow (variable assignments, computations)
  • Termination structure (base cases, recursive calls)

Remove:

  • Proof tactics (by simp, auto, lia, Proof...Qed)
  • Type system details (type classes, implicit arguments)
  • Language-specific syntax (# vs ::, @ vs ++)
  • Proof-only lemmas
  • Module qualifications
3. Extract Verification Annotations

Identify and mark:

Preconditions:

PRECONDITION: condition  [VERIFIED: lemma_name]

Postconditions:

POSTCONDITION: property  [VERIFIED: theorem_name]

Invariants:

INVARIANT: property  [VERIFIED]

Termination:

TERMINATION: argument  [VERIFIED: termination_proof]

Unverified components:

[ASSUMED: assumption]
[UNVERIFIED: property]
4. Structure the Pseudocode

Use clear, structured format:

ALGORITHM: Name
VERIFIED IN: System (theory/module name)

FUNCTION name(params: Types) -> ReturnType
  DESCRIPTION: Brief description

  PRECONDITION: conditions  [VERIFIED: source]
  POSTCONDITION: guarantees  [VERIFIED: source]

  [Algorithm body in structured pseudocode]

  TERMINATION: argument  [VERIFIED]
  INVARIANT: properties  [VERIFIED]

VERIFIED PROPERTIES:
  1. Property 1  [VERIFIED: theorem]
  2. Property 2  [VERIFIED: lemma]
5. Verify Semantic Equivalence

Check that pseudocode:

  • Has same control flow as original
  • Performs same computations
  • Maintains same data dependencies
  • Preserves all verified properties
  • Contains no new behavior
  • Omits no essential steps

Extraction Patterns

Pattern Matching

From (Isabelle):

isabelle
case xs of [] ⇒ base | (x # xs) ⇒ recursive

From (Coq):

coq
match l with | [] => base | x :: xs => recursive end

To (Pseudocode):

MATCH list WITH
  CASE []: base
  CASE x :: xs: recursive
Recursion

From:

isabelle
fun f :: "nat ⇒ nat" where
  "f 0 = 0" |
  "f (Suc n) = f n + 1"

To:

FUNCTION f(n: Nat) -> Nat
  IF n = 0 THEN
    RETURN 0
  ELSE
    RETURN f(n - 1) + 1
  [VERIFIED: terminates (decreasing n)]
Preconditions/Postconditions

From (Isabelle):

isabelle
lemma function_correct:
  assumes "precondition x"
  shows "postcondition (function x)"

To:

FUNCTION function(x: Type) -> Type
  PRECONDITION: precondition(x)  [VERIFIED: function_correct]
  POSTCONDITION: postcondition(result)  [VERIFIED: function_correct]
Dependent Types

From (Coq):

coq
Definition safe_head (l : list A) (H : l <> []) : A

To:

FUNCTION safe_head(l: List<A>) -> A
  PRECONDITION: l ≠ []  [VERIFIED: type system]

Verification Annotations

Verified Components

Mark with [VERIFIED] or [VERIFIED: source]:

PRECONDITION: is_sorted(list)  [VERIFIED: sort_correct theorem]
POSTCONDITION: result ≤ all elements  [VERIFIED: max_correct lemma]
TERMINATION: list size decreases  [VERIFIED: structural recursion]
Unverified Components

Mark clearly:

[ASSUMED: input is well-formed]
[UNVERIFIED: time complexity O(n log n)]
[UNVERIFIED: space complexity]
Partial Verification

Be specific:

[VERIFIED: correctness]
[UNVERIFIED: termination]
Unreachable Code

Mark when preconditions make cases impossible:

CASE []:
  UNREACHABLE  [precondition ensures list is non-empty]

What to Preserve vs. Remove

Always Preserve

✓ Function names and signatures ✓ Control flow structure ✓ Data dependencies ✓ Algorithmic steps ✓ Verified properties ✓ Preconditions and postconditions ✓ Loop invariants ✓ Termination arguments

Show full SKILL.md (212 more words)Show less
Always Remove

✗ Proof tactics and commands ✗ Proof scripts (proof...qed, Proof...Qed) ✗ Type class constraints (unless essential) ✗ Proof-only helper lemmas ✗ Language-specific syntax sugar ✗ Module system details ✗ Proof annotations ✗ Type inference hints

Context-Dependent

? Type annotations: Keep if essential for understanding ? Helper functions: Keep if used in algorithm, remove if proof-only ? Definitions: Keep if part of algorithm, remove if proof infrastructure

Output Format

Use structured, readable format:

ALGORITHM: [Name]
VERIFIED IN: [System] ([Module/Theory])

═══════════════════════════════════════════════════════════

FUNCTION name(params: Types) -> ReturnType
  DESCRIPTION: [Brief description]

  PRECONDITION: [conditions]  [VERIFIED: source]
  POSTCONDITION: [guarantees]  [VERIFIED: source]

  [Pseudocode body with clear structure]

  TERMINATION: [argument]  [VERIFIED]
  INVARIANT: [properties]  [VERIFIED]

═══════════════════════════════════════════════════════════

VERIFIED PROPERTIES:
  1. [Property]  [VERIFIED: theorem]
  2. [Property]  [VERIFIED: lemma]
  ...

Quality Checks

Before finalizing pseudocode:

  1. Completeness: All algorithmic steps included?
  2. Correctness: Control flow matches original?
  3. Clarity: Readable and understandable?
  4. Verification: All verified properties marked?
  5. Faithfulness: Semantically equivalent to original?
  6. No additions: No new behavior introduced?
  7. No omissions: No essential steps removed?

Examples

For complete extraction examples including:

  • Insertion sort (Isabelle/HOL)
  • Binary search (Coq)
  • Safe array access (Coq with dependent types)
  • GCD algorithm (Isabelle/HOL)

See examples.md

For detailed extraction patterns and rules: See extraction_patterns.md

Tips

  • Read proofs carefully: Understand what's verified before extracting
  • Preserve structure: Keep control flow exactly as in original
  • Mark everything: Be explicit about verification status
  • Stay faithful: Don't simplify away essential complexity
  • Remove proofs: But keep what they prove
  • Use clear syntax: Make pseudocode readable
  • Add comments: Explain non-obvious logic
  • Check equivalence: Verify semantic faithfulness
  • Distinguish verified/unverified: Be honest about what's proven
  • Keep it language-agnostic: Avoid source language idioms

© ArabelaTso, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

SKILL.md and 2 other files (references) in skills/verified-pseudocode-extractor of ArabelaTso/Skills-4-SE.

  • SKILL.md
  • references/examples.md
  • references/extraction_patterns.md

Open the folder on GitHubat commit 4f38503

Compare with similar skills

Verified Pseudocode Extractor next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Verified Pseudocode Extractor compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Verified Pseudocode Extractor this skillArabelaTso/Skills-4-SE253—~2kAutomated safety check: PassApache-2.0
Translation Diff ExportDevolutions/UniGetUI26k—~1.1kAutomated safety check: PassMIT
Sync Translationssymfony/symfony31k—~1.9kAutomated safety check: PassMIT
Translation Diff ImportDevolutions/UniGetUI26k—~750Automated safety check: PassMIT
Translation Diff TranslateDevolutions/UniGetUI26k—~934Automated safety check: PassMIT
Generate Translationspayloadcms/payload45k—~1.1kAutomated safety check: PassMIT

Similar skills

  • Translation Diff Export

    Devolutions/UniGetUI

    Compares UniGetUI JSON locale files against English, identifies untranslated or source-changed keys, and generates patch, reference, and handoff files for a target language.

    26k GitHub stars~1.1k tokensUpdated today
    Writing & ContentAuto-check passed

  • Sync Translations

    symfony/symfony

    Synchronize translation catalogs across maintained Symfony branches: find messages that newer branches added to the English catalogs but that are still missing from the oldest maintained branch…

    31k GitHub stars~1.9k tokensUpdated today
    Writing & ContentAuto-check passed

  • Translation Diff Import

    Devolutions/UniGetUI

    Merges translated key-value pairs from a UniGetUI JSON localization patch back into the full language file and validates the merged result.

    26k GitHub stars~750 tokensUpdated today
    Writing & ContentAuto-check passed

  • Translation Diff Translate

    Devolutions/UniGetUI

    Translates a sparse UniGetUI JSON language patch, writes completed entries into the working copy, preserves placeholders and terminology, and prepares the patch for merge-back.

    26k GitHub stars~934 tokensUpdated today
    Writing & ContentAuto-check passed

  • Generate Translations

    payloadcms/payload

    A skill your agent uses when new translation keys are added to packages to generate new translations strings

    45k GitHub stars~1.1k tokensUpdated today
    Writing & ContentAuto-check passed

  • InkOS Creative Harness

    Narcooo/inkos

    Drives long-form fiction, scripts, storyboards, interactive films and long-document translation through InkOS, with every change made by a typed action.

    10k GitHub starsUsed in 1 repo~1.1k tokens
    Writing & ContentAuto-check passed

More from ArabelaTso/Skills-4-SE

All 150 skills in this repo

  • Framework Migration Assistant

    ArabelaTso/Skills-4-SE

    Automatically migrate Python web applications between frameworks (Flask → FastAPI, Django → FastAPI).

    253 GitHub stars~1.9k tokensUpdated 1 mo ago
    Auto-check passed

  • Metamorphic Test Generator

    ArabelaTso/Skills-4-SE

    Generate test cases using metamorphic testing by applying transformations based on metamorphic properties.

    253 GitHub stars~798 tokensUpdated 1 mo ago
    Auto-check passed

  • Reproduction Trace Instrumenter

    ArabelaTso/Skills-4-SE

    Instruments programs to capture execution traces specifically for reproducing reported bugs, enabling consistent replay and diagnosis of failures.

    253 GitHub stars~2.4k tokensUpdated 1 mo ago
    Auto-check passed

  • Spring Mvc To Boot Migrator

    ArabelaTso/Skills-4-SE

    Automatically migrate Spring MVC applications to Spring Boot.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

  • State Snapshot Instrumenter

    ArabelaTso/Skills-4-SE

    Instrument programs (Python, C/C++, Java) to capture snapshots of key program states at runtime, including variables, memory, and call stacks.

    253 GitHub stars~2.2k tokensUpdated 1 mo ago
    Auto-check passed

Categories

Questions about Verified Pseudocode Extractor

What does Verified Pseudocode Extractor do?

Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic. Verified Pseudocode Extractor is an agent skill from ArabelaTso/Skills-4-SE. Extract language-agnostic pseudocode from formally verified programs (Isabelle/HOL, Coq) while preserving verified control flow, data dependencies, and algorithmic logic.

When should I use Verified Pseudocode Extractor?

Verified Pseudocode Extractor fits situations like: users have verified code and need readable pseudocode; documenting verified algorithms for broader audiences; translating verified implementations to other languages; creating algorithm specifications from verified code.

How do I install Verified Pseudocode Extractor in Claude Code?

Run `npx skills add ArabelaTso/Skills-4-SE --skill verified-pseudocode-extractor -a claude-code`. Or copy the skill folder (skills/verified-pseudocode-extractor in ArabelaTso/Skills-4-SE) into .claude/skills/verified-pseudocode-extractor in your project. Claude Code loads it when a task matches its description.

How do I install Verified Pseudocode Extractor in Codex?

Run `npx skills add ArabelaTso/Skills-4-SE --skill verified-pseudocode-extractor -a codex`. Or copy the skill folder (skills/verified-pseudocode-extractor in ArabelaTso/Skills-4-SE) into .agents/skills/verified-pseudocode-extractor in your project. Codex loads it when a task matches its description.

Can I use Verified Pseudocode Extractor in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add ArabelaTso/Skills-4-SE --skill verified-pseudocode-extractor -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/verified-pseudocode-extractor, .gemini/skills/verified-pseudocode-extractor, .github/skills/verified-pseudocode-extractor and .opencode/skills/verified-pseudocode-extractor in your project.

What does Verified Pseudocode Extractor need to run?

SKILL.md names no scripts, command-line tools or credentials: Verified Pseudocode Extractor is instructions for the agent only.

Does Verified Pseudocode Extractor access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is Verified Pseudocode Extractor safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Verified Pseudocode Extractor use?

Verified Pseudocode Extractor is published under the Apache-2.0 licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Verified Pseudocode Extractor use?

About 2k tokens (SKILL.md is roughly 8.1k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full. Its references folder adds about 5k tokens, read only when the agent opens those files.

What are the alternatives to Verified Pseudocode Extractor?

Skills that share tags, products or a category with Verified Pseudocode Extractor: Translation Diff Export (Devolutions/UniGetUI, 26k stars), Sync Translations (symfony/symfony, 31k stars), Translation Diff Import (Devolutions/UniGetUI, 26k stars) and Translation Diff Translate (Devolutions/UniGetUI, 26k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Verified Pseudocode Extractor?

ArabelaTso (a GitHub user) maintains it in ArabelaTso/Skills-4-SE, which has 253 GitHub stars. The repository holds 150 skills in this directory. The repository was last updated on August 21, 2026.

Source: ArabelaTso/Skills-4-SE on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.