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.

Quality

75%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide

Securityby

Passed

No findings from the security scan

Fix and improve this skill with Tessl

tessl review fix ./skills/pseudocode-extractor/SKILL.md

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):

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):

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):

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

Maintain Clarity: Pseudocode should be easier to understand than the original code
Be Consistent: Use the same conventions throughout the extraction
Preserve Intent: Focus on the algorithm's purpose, not implementation details
Use Natural Language: Write operations in plain English where possible
Show Structure: Use indentation and keywords to make control flow obvious
Add Context: Include brief comments for complex logic
Stay Abstract: Avoid language-specific constructs unless they're conceptually important
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)

Repository: ArabelaTso/Skills-4-SE
Path: skills/pseudocode-extractor/SKILL.md
Commit: 4f38503

Last updated: 5 days ago
First committed: 7 months ago

Is this your skill?

If you maintain this skill, you can claim it as your own. Once claimed, you can manage eval scenarios, bundle related skills, attach documentation or rules, and ensure cross-agent compatibility.