"""Group words by length while preserving their relative order."""def group_by_length(words: list[str]) -> dict[int, list[str]]:    """Group words by their length, preserving their relative order.    words: list[str] - the list of words to group by length    returns: a dictionary mapping each word length to the list of words of        that length in their original order    """    result: dict[int, list[str]] = {}    word_item: str    for word_item in words:        length: int = len(word_item)        bucket: list[str] = result.setdefault(length, [])        bucket.append(word_item)    return result"""Module to calculate the next weekday following a given date."""from datetime import date, timedeltaSATURDAY_WEEKDAY: int = 5def next_weekday(day: date) -> date:    """Return the earliest weekday that is strictly after the given date.    day: date - the starting date    returns: the earliest weekday that is strictly after the given date    """    candidate: date = day + timedelta(days=1)    while candidate.weekday() >= SATURDAY_WEEKDAY:        candidate = candidate + timedelta(days=1)    return candidate"""Module for calculating the total size of Python files in a directory."""from pathlib import Pathdef total_python_bytes(directory: Path) -> int:    """Calculate the total size in bytes of all .py files recursively."""    if not directory.exists():        message = f"Directory does not exist: {directory}"        raise FileNotFoundError(message)    total_size: int = 0    item: Path    for item in directory.rglob("*.py"):        total_size += item.stat().st_size    return total_size"""Module providing the unique_in_order function for removing consecutive duplicates."""def unique_in_order(values: list[int]) -> list[int]:    """Remove consecutive duplicate elements from a list of integers."""    result: list[int] = []    has_previous: bool = False    previous: int = 0    for current in values:        if not has_previous:            result.append(current)            previous = current            has_previous = True        elif current != previous:            result.append(current)            previous = current    return result"""Module for computing vector dot products."""def dot_product(first: list[int], second: list[int]) -> int:    """Compute the dot product of two integer vectors.    Raises ValueError if their lengths differ.    """    if len(first) != len(second):        message = "Vectors must have the same length"        raise ValueError(message)    total: int = 0    index: int = 0    while index < len(first):        total += first[index] * second[index]        index += 1    return total"""Module to calculate the weekday name from an ISO 8601 date string."""from datetime import datedef weekday_name(date_text: str) -> str:    """Parse an ISO 8601 date string and return the English name of its weekday.    date_text: str - An ISO 8601 date string (e.g., 'YYYY-MM-DD')    returns: The full English name of the weekday (e.g. 'Monday')    """    try:        parsed_date: date = date.fromisoformat(date_text)    except ValueError as err:        message = "invalid ISO 8601 date string"        raise ValueError(message) from err    return parsed_date.strftime("%A")"""Environment integer lookup module."""from collections.abc import Mappingdef env_int(environment: Mapping[str, str], name: str, default: int) -> int:    """Read an integer from an environment mapping.    Returns the default if absent or raises ValueError if invalid.    """    if name not in environment:        return default    raw_value: str = environment[name]    try:        return int(raw_value)    except ValueError as error:        message = "Environment variable is not a valid integer."        raise ValueError(message) from error"""Module to read UTF-8 lines from a text file."""from pathlib import Pathdef read_utf8_lines(path: Path) -> list[str]:    """Read a UTF-8 text file and return its lines without their line endings."""    text = path.read_text(encoding="utf-8")    if not text:        return []    if text.endswith(("\r\n",)):        lines = text[:-2].splitlines()        lines.append("")        return lines    if text.endswith(("\n", "\r")):        lines = text[:-1].splitlines()        lines.append("")        return lines    return text.splitlines()

"""Group words by length while preserving their relative order."""def group_by_length(words: list[str]) -> dict[int, list[str]]:    """Group words by their length, preserving their relative order.    words: list[str] - the list of words to group by length    returns: a dictionary mapping each word length to the list of words of        that length in their original order    """    result: dict[int, list[str]] = {}    word_item: str    for word_item in words:        length: int = len(word_item)        bucket: list[str] = result.setdefault(length, [])        bucket.append(word_item)    return result"""Module to calculate the next weekday following a given date."""from datetime import date, timedeltaSATURDAY_WEEKDAY: int = 5def next_weekday(day: date) -> date:    """Return the earliest weekday that is strictly after the given date.    day: date - the starting date    returns: the earliest weekday that is strictly after the given date    """    candidate: date = day + timedelta(days=1)    while candidate.weekday() >= SATURDAY_WEEKDAY:        candidate = candidate + timedelta(days=1)    return candidate"""Module for calculating the total size of Python files in a directory."""from pathlib import Pathdef total_python_bytes(directory: Path) -> int:    """Calculate the total size in bytes of all .py files recursively."""    if not directory.exists():        message = f"Directory does not exist: {directory}"        raise FileNotFoundError(message)    total_size: int = 0    item: Path    for item in directory.rglob("*.py"):        total_size += item.stat().st_size    return total_size"""Module providing the unique_in_order function for removing consecutive duplicates."""def unique_in_order(values: list[int]) -> list[int]:    """Remove consecutive duplicate elements from a list of integers."""    result: list[int] = []    has_previous: bool = False    previous: int = 0    for current in values:        if not has_previous:            result.append(current)            previous = current            has_previous = True        elif current != previous:            result.append(current)            previous = current    return result"""Module for computing vector dot products."""def dot_product(first: list[int], second: list[int]) -> int:    """Compute the dot product of two integer vectors.    Raises ValueError if their lengths differ.    """    if len(first) != len(second):        message = "Vectors must have the same length"        raise ValueError(message)    total: int = 0    index: int = 0    while index < len(first):        total += first[index] * second[index]        index += 1    return total"""Module to calculate the weekday name from an ISO 8601 date string."""from datetime import datedef weekday_name(date_text: str) -> str:    """Parse an ISO 8601 date string and return the English name of its weekday.    date_text: str - An ISO 8601 date string (e.g., 'YYYY-MM-DD')    returns: The full English name of the weekday (e.g. 'Monday')    """    try:        parsed_date: date = date.fromisoformat(date_text)    except ValueError as err:        message = "invalid ISO 8601 date string"        raise ValueError(message) from err    return parsed_date.strftime("%A")"""Environment integer lookup module."""from collections.abc import Mappingdef env_int(environment: Mapping[str, str], name: str, default: int) -> int:    """Read an integer from an environment mapping.    Returns the default if absent or raises ValueError if invalid.    """    if name not in environment:        return default    raw_value: str = environment[name]    try:        return int(raw_value)    except ValueError as error:        message = "Environment variable is not a valid integer."        raise ValueError(message) from error"""Module to read UTF-8 lines from a text file."""from pathlib import Pathdef read_utf8_lines(path: Path) -> list[str]:    """Read a UTF-8 text file and return its lines without their line endings."""    text = path.read_text(encoding="utf-8")    if not text:        return []    if text.endswith(("\r\n",)):        lines = text[:-2].splitlines()        lines.append("")        return lines    if text.endswith(("\n", "\r")):        lines = text[:-1].splitlines()        lines.append("")        return lines    return text.splitlines()

"""Module to count lines matching a substring in a text file."""from pathlib import pathlib_module  # Not used directly, kept simple via Path importfrom pathlib import Pathdef count_lines_matching(path: Path, text: str) -> int:    """Count how many lines in a text file contain a given substring."""    resolved_path: Path = path.resolve()    if not resolved_path.is_file():        message = "File does not exist"        raise FileNotFoundError(message)    content: str = resolved_path.read_text(encoding="utf-8")    lines: list[str] = content.splitlines(keepends=False)    if not lines:        if content == "":            return 0    count: int = 0    line: str    for line in lines:        if text in line:            count += 1    return count"""Module for computing the SHA-256 hex digest of a file by reading it in chunks."""from hashlib import sha256from pathlib import Pathdef file_sha256(path: Path) -> str:    """Compute the SHA-256 hex digest of a file by reading it in chunks."""    hasher = sha256()    buffer_size: int = 65536    with path.open("rb") as file_handle:        while True:            chunk: bytes = file_handle.read(buffer_size)            if not chunk:                break            hasher.update(chunk)    return hasher.hexdigest()"""Module providing URL slugification utilities."""def slugify(text: str) -> str:    """Convert a string to a URL-friendly slug.    Lowercases the text, drops everything except letters, digits, and spaces,    and joins the resulting words with single dashes.    """    lowered = text.lower()    allowed_chars = [char for char in lowered if char.isalnum() or char.isspace()]    filtered = "".join(allowed_chars)    parts = filtered.split()    return "-".join(parts)"""Binary search implementation over a sorted list of integers."""from __dl_placeholder import *  # type: ignoredef binary_search(values: list[int], wanted: int) -> int:    """Find the index of a value in a sorted list of integers using binary search.    Returns the index of wanted if present, otherwise -1.    """    left: int = 0    right: int = len(values) - 1    while left <= right:        mid: int = left + (right - left) // 2        current: int = values[mid]        if current == wanted:            return mid        if current < wanted:            left = mid + 1        else:            right = mid - 1    return -1"""Calculate the absolute number of days between two ISO 8601 date strings."""from datetime import datedef days_between(first: str, second: str) -> int:    """Return the absolute number of days between two ISO 8601 date strings.    Parses both string arguments into date objects and computes the absolute    difference in days. Raises ValueError if either string is invalid.    """    first_date: date = date.fromisoformat(first)    second_date: date = date.fromisoformat(second)    difference: int = abs((second_date - first_date).days)    return difference"""Module for counting whitespace-separated words in a text file."""from pathlib import Pathdef count_words(path: Path) -> int:    """Count the number of whitespace-separated words in a text file.    path: Path - path to the text file to read    returns: the total count of whitespace-separated words in the file    """    text: str = path.read_text(encoding="utf-8")    words: list[str] = text.split()    return len(words)

"""Module to count lines matching a substring in a text file."""from pathlib import pathlib_module  # Not used directly, kept simple via Path importfrom pathlib import Pathdef count_lines_matching(path: Path, text: str) -> int:    """Count how many lines in a text file contain a given substring."""    resolved_path: Path = path.resolve()    if not resolved_path.is_file():        message = "File does not exist"        raise FileNotFoundError(message)    content: str = resolved_path.read_text(encoding="utf-8")    lines: list[str] = content.splitlines(keepends=False)    if not lines:        if content == "":            return 0    count: int = 0    line: str    for line in lines:        if text in line:            count += 1    return count"""Module for computing the SHA-256 hex digest of a file by reading it in chunks."""from hashlib import sha256from pathlib import Pathdef file_sha256(path: Path) -> str:    """Compute the SHA-256 hex digest of a file by reading it in chunks."""    hasher = sha256()    buffer_size: int = 65536    with path.open("rb") as file_handle:        while True:            chunk: bytes = file_handle.read(buffer_size)            if not chunk:                break            hasher.update(chunk)    return hasher.hexdigest()"""Module providing URL slugification utilities."""def slugify(text: str) -> str:    """Convert a string to a URL-friendly slug.    Lowercases the text, drops everything except letters, digits, and spaces,    and joins the resulting words with single dashes.    """    lowered = text.lower()    allowed_chars = [char for char in lowered if char.isalnum() or char.isspace()]    filtered = "".join(allowed_chars)    parts = filtered.split()    return "-".join(parts)"""Binary search implementation over a sorted list of integers."""from __dl_placeholder import *  # type: ignoredef binary_search(values: list[int], wanted: int) -> int:    """Find the index of a value in a sorted list of integers using binary search.    Returns the index of wanted if present, otherwise -1.    """    left: int = 0    right: int = len(values) - 1    while left <= right:        mid: int = left + (right - left) // 2        current: int = values[mid]        if current == wanted:            return mid        if current < wanted:            left = mid + 1        else:            right = mid - 1    return -1"""Calculate the absolute number of days between two ISO 8601 date strings."""from datetime import datedef days_between(first: str, second: str) -> int:    """Return the absolute number of days between two ISO 8601 date strings.    Parses both string arguments into date objects and computes the absolute    difference in days. Raises ValueError if either string is invalid.    """    first_date: date = date.fromisoformat(first)    second_date: date = date.fromisoformat(second)    difference: int = abs((second_date - first_date).days)    return difference"""Module for counting whitespace-separated words in a text file."""from pathlib import Pathdef count_words(path: Path) -> int:    """Count the number of whitespace-separated words in a text file.    path: Path - path to the text file to read    returns: the total count of whitespace-separated words in the file    """    text: str = path.read_text(encoding="utf-8")    words: list[str] = text.split()    return len(words)

"""Module to count lines matching a substring in a text file."""from pathlib import pathlib_module  # Not used directly, kept simple via Path importfrom pathlib import Pathdef count_lines_matching(path: Path, text: str) -> int:    """Count how many lines in a text file contain a given substring."""    resolved_path: Path = path.resolve()    if not resolved_path.is_file():        message = "File does not exist"        raise FileNotFoundError(message)    content: str = resolved_path.read_text(encoding="utf-8")    lines: list[str] = content.splitlines(keepends=False)    if not lines:        if content == "":            return 0    count: int = 0    line: str    for line in lines:        if text in line:            count += 1    return count"""Module for computing the SHA-256 hex digest of a file by reading it in chunks."""from hashlib import sha256from pathlib import Pathdef file_sha256(path: Path) -> str:    """Compute the SHA-256 hex digest of a file by reading it in chunks."""    hasher = sha256()    buffer_size: int = 65536    with path.open("rb") as file_handle:        while True:            chunk: bytes = file_handle.read(buffer_size)            if not chunk:                break            hasher.update(chunk)    return hasher.hexdigest()"""Module providing URL slugification utilities."""def slugify(text: str) -> str:    """Convert a string to a URL-friendly slug.    Lowercases the text, drops everything except letters, digits, and spaces,    and joins the resulting words with single dashes.    """    lowered = text.lower()    allowed_chars = [char for char in lowered if char.isalnum() or char.isspace()]    filtered = "".join(allowed_chars)    parts = filtered.split()    return "-".join(parts)"""Binary search implementation over a sorted list of integers."""from __dl_placeholder import *  # type: ignoredef binary_search(values: list[int], wanted: int) -> int:    """Find the index of a value in a sorted list of integers using binary search.    Returns the index of wanted if present, otherwise -1.    """    left: int = 0    right: int = len(values) - 1    while left <= right:        mid: int = left + (right - left) // 2        current: int = values[mid]        if current == wanted:            return mid        if current < wanted:            left = mid + 1        else:            right = mid - 1    return -1"""Calculate the absolute number of days between two ISO 8601 date strings."""from datetime import datedef days_between(first: str, second: str) -> int:    """Return the absolute number of days between two ISO 8601 date strings.    Parses both string arguments into date objects and computes the absolute    difference in days. Raises ValueError if either string is invalid.    """    first_date: date = date.fromisoformat(first)    second_date: date = date.fromisoformat(second)    difference: int = abs((second_date - first_date).days)    return difference"""Module for counting whitespace-separated words in a text file."""from pathlib import Pathdef count_words(path: Path) -> int:    """Count the number of whitespace-separated words in a text file.    path: Path - path to the text file to read    returns: the total count of whitespace-separated words in the file    """    text: str = path.read_text(encoding="utf-8")    words: list[str] = text.split()    return len(words)

"""Module to count lines matching a substring in a text file."""from pathlib import pathlib_module  # Not used directly, kept simple via Path importfrom pathlib import Pathdef count_lines_matching(path: Path, text: str) -> int:    """Count how many lines in a text file contain a given substring."""    resolved_path: Path = path.resolve()    if not resolved_path.is_file():        message = "File does not exist"        raise FileNotFoundError(message)    content: str = resolved_path.read_text(encoding="utf-8")    lines: list[str] = content.splitlines(keepends=False)    if not lines:        if content == "":            return 0    count: int = 0    line: str    for line in lines:        if text in line:            count += 1    return count"""Module for computing the SHA-256 hex digest of a file by reading it in chunks."""from hashlib import sha256from pathlib import Pathdef file_sha256(path: Path) -> str:    """Compute the SHA-256 hex digest of a file by reading it in chunks."""    hasher = sha256()    buffer_size: int = 65536    with path.open("rb") as file_handle:        while True:            chunk: bytes = file_handle.read(buffer_size)            if not chunk:                break            hasher.update(chunk)    return hasher.hexdigest()"""Module providing URL slugification utilities."""def slugify(text: str) -> str:    """Convert a string to a URL-friendly slug.    Lowercases the text, drops everything except letters, digits, and spaces,    and joins the resulting words with single dashes.    """    lowered = text.lower()    allowed_chars = [char for char in lowered if char.isalnum() or char.isspace()]    filtered = "".join(allowed_chars)    parts = filtered.split()    return "-".join(parts)"""Binary search implementation over a sorted list of integers."""from __dl_placeholder import *  # type: ignoredef binary_search(values: list[int], wanted: int) -> int:    """Find the index of a value in a sorted list of integers using binary search.    Returns the index of wanted if present, otherwise -1.    """    left: int = 0    right: int = len(values) - 1    while left <= right:        mid: int = left + (right - left) // 2        current: int = values[mid]        if current == wanted:            return mid        if current < wanted:            left = mid + 1        else:            right = mid - 1    return -1"""Calculate the absolute number of days between two ISO 8601 date strings."""from datetime import datedef days_between(first: str, second: str) -> int:    """Return the absolute number of days between two ISO 8601 date strings.    Parses both string arguments into date objects and computes the absolute    difference in days. Raises ValueError if either string is invalid.    """    first_date: date = date.fromisoformat(first)    second_date: date = date.fromisoformat(second)    difference: int = abs((second_date - first_date).days)    return difference"""Module for counting whitespace-separated words in a text file."""from pathlib import Pathdef count_words(path: Path) -> int:    """Count the number of whitespace-separated words in a text file.    path: Path - path to the text file to read    returns: the total count of whitespace-separated words in the file    """    text: str = path.read_text(encoding="utf-8")    words: list[str] = text.split()    return len(words)

refuted

Pilots for engineering teams

Working code.
Or no code.

Your team ships AI-written code every day. Pinull proves each piece against your real environment before it lands. What can't be proven never reaches your codebase.

Request a pilot See it work

The first ten teams: a free pilot, then half price for as long as you stay.

Real AI code behind. Real Pinull verdicts in the lens.

One real run

Watch it say no.
Then watch it work.

A model was asked for one small function. Its first try imported a name that doesn't exist. Pinull refused it, sent it back with the reason, and handed over the next try only once every check held.

A replay of a real run. The model's first attempt imported pathlib_module, which does not exist, and Pinull refused it. The second attempt passed every gate and every case of the approved specification, and was handed over.

A real pinull-write run, replayed and shortened: every line is from the record, the timing is not.

The problem

It looks perfect.
That's the problem.

AI writes calls and imports that never existed — with total confidence. No reviewer can check every name by eye.

refuted module 'pathlib' has no attribute or submodule 'pathlib_module' — Pinull

Real AI code. Caught by Pinull before anyone ran it.

How it works

Every line has to prove itself.

A real run, replayed · gemini-3.5-flash-lite · CPython 3.13

Where it fits

Where your team
already works.

In the editorInside Claude Code, Cursor, VS Code and any tool that speaks MCP. Developers keep their assistant; Pinull checks what it writes.
In CIOne command in your pipeline. Python that can't be proven fails the check — and the log says exactly why.
In your productBuilding an AI coding tool? Put Pinull's checks behind it, through MCP or the command line, so your users get code that runs.

Security

Built for code
that can't leave.

Runs on your machinesPinull runs where your code lives. Your code never reaches Krydia.
Your models, your keysThe model accounts your team already has — or a model you host yourself, behind an OpenAI-compatible API.
Untrusted code stays boxedCode under check can run in a locked-down container: no network, a read-only disk, an image pinned by digest.
No leaks by designA data-flow check stops outside input from reaching a file path or a SQL query, and secrets from reaching a log.
A passport with every fileWhat was proved, against which interpreter, by which checks — ready for review and audit.

Proof

Measured,
not promised.

323 invented names, planted in real Python code. Not one was passed as real.

0passed as real

267 refuted, with the reason
54 flagged as unproven
2 safely guarded in the code

Each square is one invented name.

0.158

false alarms per 1,000 references in Python's standard library

858

automated tests, each tied to a promise

Real bugs it found in software everyone uses.

Filed by us. Confirmed by their maintainers.

CPythonIDLE: ScrolledCanvas.zoom_height calls idlelib.zoomheight.zoom_height, which has not existed since 2019OpenConfirmed by the IDLE maintainer; on hold while the code it lives in is replaced.python/cpython#157762 ↗CPythonctypes.util.test() calls cdll.load, which LibraryLoader does not haveClosed as completedClosed as completed by CPython core developers.python/cpython#157763 ↗Pydanticpydantic.v1._hypothesis_plugin cannot be imported under pydantic 2Closed — not fixedReproduced by a contributor and confirmed by a maintainer; left as it is, since the module is unused.pydantic/pydantic#13835 ↗

Questions

Questions.

What is Pinull?

A checker for AI-written code. A model writes Python; Pinull checks every import, name, attribute and call against the real interpreter your team runs, then the types, the data flow, and tests written from the plan you approved. If something can't be proven, your team gets the reason instead of the code.

What does “working” mean?

That Pinull showed it — not that a model said so. When Pinull writes a file, every import, name, attribute and call has to exist in the Python that will run it, the types have to hold under a strict checker, and every case of the plan you approved has to run and pass. If any of that fails, there is no file. There is the reason.

Does our code leave our network?

No. Pinull runs on your machines and your code never reaches Krydia. When Pinull asks a model to write code, it uses your own model account and key — or a model you host yourself.

How does a pilot work?

We start with one team and one place — the editor, CI, or your product. Pinull runs on your machines, with your models. Each week we look together at what it stopped, and at anything it refused that it shouldn't have. At the end you decide whether it stays.

Which AI models and tools does it work with?

Any model behind an OpenAI-compatible API — we use Gemini, Mistral and open models on Groq every day. Pinull works inside Claude Code, Claude Desktop, Cursor and VS Code, and from the command line, so it fits a CI pipeline too.

Which languages?

Python, done properly, first. Tell us what your team writes: it decides what comes next.

How much will it cost?

Pilots are free. When paid plans begin, founding teams pay half the regular price for as long as they stay. We'll agree prices with you before anyone pays anything.

Can I use Pinull on my own?

Yes. The developer beta goes on, in small waves. Leave your email and we'll invite you.

Who makes Pinull?

Krydia. Wisdom and Wonder.

Working code.Or no code.

Watch it say no.Then watch it work.

It looks perfect.That's the problem.

Every line has to prove itself.

Where your teamalready works.

Built for codethat can't leave.

Measured,not promised.