Skip to content
Skills Library
Programming · Conversion & formats

pseudocode-extractor

/pseudocode-extractor

Extract programming-language-agnostic pseudocode from source code in any language, preserving control flow and logical structure while filtering out implementation details. Use when the user asks to convert code to pseudocode, abstract code logic, understand code structure without syntax, create language-independent documentation, or analyze algorithmic flow without language-specific details.

Repository
Skills-4-SE ↗
Licence
Apache-2.0
Last repository change
21.08.2026

Assessment and security

100/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content35 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 21.08.2026, without references to retired models or APIs.

Licence

Apache-2.0, otwarta: można używać i zmieniać, z zachowaniem licencji i informacji o zmianach.

What it does and when to use it

Extract programming-language-agnostic pseudocode from source code in any language, preserving control flow and logical structure while filtering out implementation details. Use when the user asks to convert code to pseudocode, abstract code logic, understand code structure without syntax, create language-independent documentation, or analyze algorithmic flow without language-specific details.

Original author description

Extract programming-language-agnostic pseudocode from source code in any language, preserving control flow and logical structure while filtering out implementation details. Use when the user asks to convert code to pseudocode, abstract code logic, understand code structure without syntax, create language-independent documentation, or analyze algorithmic flow without language-specific details.

How it works

  1. Overview
  2. Extraction Process
  3. Examples
  4. Best Practices
  5. Common Patterns
Original SKILL.md headings · 303 lines, 910 words
SKILL.md preview
---
name: pseudocode-extractor
description: Extract programming-language-agnostic pseudocode from source code in any language, preserving control flow and logical structure while filtering out implementation details. Use when the user asks to convert code to pseudocode, abstract code logic, understand code structure without syntax, create language-independent documentation, or analyze algorithmic flow without language-specific details.
---

# Pseudocode Extractor

## Overview

Transform source code from any programming language into clear, language-agnostic pseudocode that captures the essential logic and control flow while removing syntax-specific details.

## Extraction Process

### 1. Analyze Input Code

First, identify the programming language and understand the code structure:
- Recognize functions, classes, methods, and modules
- Identify control flow structures (loops, conditionals, error handling)
- Note data structures and their relationships
- Understand the overall algorithmic approach

### 2. Extract Core Logic

Focus on WHAT the code does, not HOW it's implemented:

**Preserve:**
- Function/method names and their purpose
- Control flow (if/else, loops, switch/case logic)
- Logical operations and conditions
- Data transformations and assignments
- Function calls and their relationships
- Class structures and inheritance relationships
- Key variable names that convey meaning

**Filter out:**
- Language-specific syntax (semicolons, braces, keywords)
- Type declarations and annotations
- Import/include statements (unless critical to understanding)
- Error handling boilerplate (try/catch unless the logic is important)
- Memory management details
- Language-specific idioms
- Verbose getter/setter methods
- Standard library implementation details

### 3. Format Pseudocode

Use clear, readable pseudocode conventions:

**Structure:**
```
FUNCTION function_name(parameters)
    // High-level description of what function does

    IF condition THEN
        action
    ELSE IF another_condition THEN
        another_action
    ELSE
        default_action
    END IF

    FOR EACH item IN collection DO
        process item
    END FOR

    WHILE condition DO
        action
    END WHILE

    RETURN result
END FUNCTION
```

**Conventions:**
- Use UPPERCASE for keywords (FUNCTION, IF, FOR, WHILE, RETURN, etc.)
- Use descriptive names in lowercase or camelCase
- Indent to show nesting and structure
- Use comments to explain complex logic
- Keep operations at a high level of abstraction
- Use mathematical notation where appropriate (←, ≠, ≤, etc.)

### 4. Organize Output

Structure the pseudocode to match the original code organization:

**For single functions:**
- Start with function signature
- Add brief description
- Show main logic flow
- Note return value

**For classes:**
- Show class name and inheritance
- List key attributes
- Show method signatures with brief descriptions
- Detail only the most important methods

**For modules/files:**
- Group related functions
- Show high-level module structure
- Indicate dependencies between components
- Use section headers for clarity

## Examples

### Example 1: Simple Function

**Input (Python):**
```python
def calculate_discount(price, customer_type):
    if customer_type == "premium":
        discount = 0.20
    elif customer_type == "regular":
        discount = 0.10
    else:
        discount = 0.05

    final_price = price * (1 - discount)
    return round(final_price, 2)
```

**Output (Pseudocode):**
```
FUNCTION calculate_discount(price, customer_type)
    // Calculate final price after applying customer-specific discount

    IF customer_type is "premium" THEN
        discount ← 20%
    ELSE IF customer_type is "regular" THEN
        discount ← 10%
    ELSE
        discount ← 5%
    END IF

    final_price ← price × (1 - discount)

    RETURN final_price rounded to 2 decimals
END FUNCTION
```

### Example 2: Loop with Data Processing

**Input (JavaScript):**
```javascript
function filterActiveUsers(users) {
    const activeUsers = [];
    for (let i = 0; i < users.length; i++) {
        if (users[i].lastLogin !== null &&
            users[i].status === 'active') {
            activeUsers.push({
                id: users[i].id,
                name: users[i].name
            });
        }
    }
    return activeUsers;
}
```

**Output (Pseudocode):**
```
FUNCTION filter_active_users(users)
    // Extract active users who have logged in at least once

    active_users ← empty list

    FOR EACH user IN users DO
        IF user has logged in AND user status is "active" THEN
            ADD user.id and user.name to active_users
        END IF
    END FOR

    RETURN active_users
END FUNCTION
```

### Example 3: Class Structure

**Input (Java):**
```java
public class ShoppingCart {
    private List<Item> items;
    private double totalPrice;

    public ShoppingCart() {
        this.items = new ArrayList<>();
        this.totalPrice = 0.0;
    }

    public void addItem(Item item) {
        items.add(item);
        totalPrice += item.getPrice();
    }

    public void removeItem(String itemId) {
        for (int i = 0; i < items.size(); i++) {
            if (items.get(i).getId().equals(itemId)) {
                totalPrice -= items.get(i).getPrice();
                items.remove(i);
                break;
            }
        }
    }

    public double getTotalPrice() {
        return totalPrice;
    }
}
```

**Output (Pseudocode):**
```
CLASS ShoppingCart
    ATTRIBUTES:
        items: list of Item objects
        total_price: numeric value

    CONSTRUCTOR
        Initialize empty items list
        Set total_price to 0
    END CONSTRUCTOR

    METHOD add_item(item)
        Add item to items list
        Increase total_price by item price
    END METHOD

    METHOD remove_item(item_id)
        FOR EACH item IN items DO
            IF item.id equals item_id THEN
                Decrease total_price by item price
                Remove item from items list
                EXIT loop
            END IF
        END FOR
    END METHOD

    METHOD get_total_price()
        RETURN total_price
    END METHOD
END CLASS
```

## Best Practices

1. **Maintain Clarity**: Pseudocode should be easier to understand than the original code
2. **Be Consistent**: Use the same conventions throughout the extraction
3. **Preserve Intent**: Focus on the algorithm's purpose, not implementation details
4. **Use Natural Language**: Write operations in plain English where possible
5. **Show Structure**: Use indentation and keywords to make control flow obvious
6. **Add Context**: Include brief comments for complex logic
7. **Stay Abstract**: Avoid language-specific constructs unless they're conceptually important
8. **Group Related Logic**: Keep related operations together for readability

## Common Patterns

### Conditional Logic
```
IF condition THEN
    action
ELSE IF another_condition THEN
    another_action
ELSE
    default_action
END IF
```

### Loops
```
FOR i FROM 1 TO n DO
    action
END FOR

FOR EACH element IN collection DO
    process element
END FOR

WHILE condition DO
    action
END WHILE

REPEAT
    action
UNTIL condition
```

### Data Operations
```
// Assignment
variable ← value

// Comparison
IF x > y THEN ...
IF x ≠ y THEN ...

// Collections
ADD item TO list
REMOVE item FROM list
FIND item IN list WHERE condition
```

### Function Calls
```
result ← function_name(arguments)
CALL procedure_name(arguments)
```

Versions

The database has no other skills named pseudocode-extractor.

Database snapshot: 13.11.2026 · package version aa80813f17d9 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100verified-pseudocode-extractor
    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…
  • 100pseudocode-to-java-code
    Converts pseudocode descriptions and algorithm specifications into complete, executable Java code. Use this skill when you need to implement algorithms from pseudocode, translate algorithm descriptions to Java, generate Java code from specifications, convert textbook algorithms…
  • 100ape-write-pseudocode
    Guidelines for writing pseudocode for functions and algorithms. Use this skill whenever the user asks to write pseudocode, sketch out an algorithm, or describe the logic of a function at a high level. Trigger on phrases like "write pseudocode", "sketch this algorithm",…
  • 90design-pseudocode
    Design a routine by stepwise refinement — pseudocode the intent before coding, then promote it to comments. Use when designing a complex function or non-trivial algorithm.
  • 100show-me
    Explain code structure, dataflow, or proposed changes with a compact tree, pseudocode, type signature, diff, or diagram. Use when a visual clarifies those relationships; whole-repo briefings belong to grok-repo.
  • 100refactor
    Behavior-preserving code refactoring. Use when the user asks to simplify complex or duplicated code, improve naming, control flow, or module structure, extract code, or clean up an implementation without changing functionality. Preserve public APIs unless the user explicitly authorizes a change.

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.