DEV Community: Kyle Keon

Build a High-Speed Duplicate File Finder & Disk Analyzer in Pure Python

Kyle Keon — Mon, 02 Nov 2026 07:21:11 +0000

Most Python "file management" tutorials stop at a 30-line shutil.move() loop that sorts files by extension. While great for learning pathlib, that doesn't help when you need to reclaim gigabytes of wasted space across tens of thousands of files without waiting 20 minutes for hashlib to read your entire hard drive.

In this post, we'll build a production-grade Multithreaded Duplicate & Storage Analyzer CLI using pure Python 3.10+ (zero external dependencies) that can scan tens of thousands of files in seconds.

Why Naive Duplicate Finders Are Slow

If you run sha256() on every file in a 500 GB directory, your script is immediately bottlenecked by disk I/O. To avoid reading every byte on the drive, we can use a 3-Stage Hashing Funnel:

Stage 1: Byte-Size Grouping (O(1) metadata lookup) — Two files cannot be identical if their byte counts differ. Grouping by stat().st_size eliminates ~85–95% of files immediately without opening a single file handle.
Stage 2: 4 KB Head/Tail blake2b Sampling — For files that share the exact same size, we read only the first 4 KB and last 4 KB of the file and hash those 8 KB with hashlib.blake2b. This eliminates 99% of remaining false positives (like similarly sized photos or video chunks) in milliseconds.
Stage 3: Streaming Full SHA-256 Verification — Only files that match in both byte size and 8 KB edge signatures undergo a full 1 MB chunked SHA-256 hash across a ThreadPoolExecutor.

On top of that, instead of destructively deleting files (os.remove), every quarantine operation writes to a local JSON transaction log (~/.storage_audit_manifest.json) so you can revert your last batch action with a single undo command.

The Complete Script (`disk_audit.py`)

Save the following code as disk_audit.py. It requires Python 3.10+ and uses only the standard library:


python
#!/usr/bin/env python3
"""
High-speed disk analyzer, duplicate finder, and reversible file manager.
Zero external dependencies (Python 3.10+ standard library only).
"""

import argparse
import hashlib
import json
import os
import shutil
import sys
import time
from collections import defaultdict
from concurrent.futures import ThreadPoolExecutor, as_completed
from dataclasses import dataclass
from datetime import datetime
from pathlib import Path
from typing import Dict, List, Optional, Tuple

MANIFEST_FILE = Path.home() / ".storage_audit_manifest.json"
CHUNK_SIZE = 1024 * 1024  # 1 MB streaming buffer
SAMPLE_SIZE = 4096        # 4 KB fast header/footer sample


@dataclass(frozen=True)
class FileRecord:
    path: Path
    size: int
    mtime: float


def format_bytes(size: int) -> str:
    """Converts raw byte counts into human-readable units."""
    for unit in ("B", "KB", "MB", "GB", "TB"):
        if size < 1024 or unit == "TB":
            return f"{size:.2f} {unit}" if unit != "B" else f"{size} B"
        size /= 1024
    return f"{size} B"


def fast_sample_hash(path: Path, size: int) -> Optional[str]:
    """Reads only the first and last 4KB of a file to quickly filter non-duplicates."""
    try:
        hasher = hashlib.blake2b(digest_size=16)
        with path.open("rb") as f:
            hasher.update(f.read(SAMPLE_SIZE))
            if size > SAMPLE_SIZE * 2:
                f.seek(-SAMPLE_SIZE, os.SEEK_END)
                hasher.update(f.read(SAMPLE_SIZE))
        return hasher.hexdigest()
    except (OSError, PermissionError):
        return None


def full_sha256(path: Path) -> Optional[str]:
    """Computes full SHA-256 digest using memory-efficient 1MB chunks."""
    try:
        hasher = hashlib.sha256()
        with path.open("rb") as f:
            while chunk := f.read(CHUNK_SIZE):
                hasher.update(chunk)
        return hasher.hexdigest()
    except (OSError, PermissionError):
        return None


def scan_filesystem(root: Path, min_size: int = 1024) -> List[FileRecord]:
    """Recursively yields regular files, skipping symlinks and system directories."""
    records: List[FileRecord] = []
    skip_dirs = {
        ".git", "node_modules", ".venv", "__pycache__",
        "$RECYCLE.BIN", "System Volume Information"
    }

    for dirpath, dirnames, filenames in os.walk(root, topdown=True):
        # Prune ignored and hidden directories in-place
        dirnames[:] = [
            d for d in dirnames
            if d not in skip_dirs and not d.startswith(".")
        ]

        for fname in filenames:
            if fname.startswith("."):
                continue
            fpath = Path(dirpath) / fname
            try:
                if fpath.is_symlink():
                    continue
                stat = fpath.stat()
                if stat.st_size >= min_size:
                    records.append(FileRecord(fpath, stat.st_size, stat.st_mtime))
            except (OSError, PermissionError):
                continue
    return records


def find_duplicates(root: Path, min_size: int, workers: int) -> Dict[str, List[FileRecord]]:
    """Three-stage pipeline: Size grouping -> 8KB Blake2b sample -> Full SHA-256."""
    t0 = time.perf_counter()
    print(f"[*] Scanning '{root}' (min size: {format_bytes(min_size)})...")
    files = scan_filesystem(root, min_size)
    print(f"    Indexed {len(files):,} candidate files in {time.perf_counter() - t0:.2f}s.")

    # Stage 1: Group by exact byte size
    by_size: Dict[int, List[FileRecord]] = defaultdict(list)
    for rec in files:
        by_size[rec.size].append(rec)
    size_candidates = [
        rec for group in by_size.values() if len(group) > 1 for rec in group
    ]
    print(f"[*] Stage 1 (Size match): Narrowed to {len(size_candidates):,} files.")

    if not size_candidates:
        return {}

    # Stage 2: Parallel 4KB head/tail signature
    by_sample: Dict[Tuple[int, str], List[FileRecord]] = defaultdict(list)
    with ThreadPoolExecutor(max_workers=workers) as pool:
        future_map = {
            pool.submit(fast_sample_hash, r.path, r.size): r
            for r in size_candidates
        }
        for future in as_completed(future_map):
            rec = future_map[future]
            sig = future.result()
            if sig:
                by_sample[(rec.size, sig)].append(rec)

    sample_candidates = [
        rec for group in by_sample.values() if len(group) > 1 for rec in group
    ]
    print(f"[*] Stage 2 (4KB edge hash): Narrowed to {len(sample_candidates):,} files.")

    if not sample_candidates:
        return {}

    # Stage 3: Full SHA-256 verification
    by_full_hash: Dict[str, List[FileRecord]] = defaultdict(list)
    with ThreadPoolExecutor(max_workers=workers) as pool:
        future_map = {
            pool.submit(full_sha256, r.path): r
            for r in sample_candidates
        }
        for future in as_completed(future_map):
            rec = future_map[future]
            digest = future.result()
            if digest:
                by_full_hash[digest].append(rec)

    confirmed = {
        digest: sorted(group, key=lambda r: r.mtime)
        for digest, group in by_full_hash.items()
        if len(group) > 1
    }
    return confirmed


def record_transaction(operations: List[Dict[str, str]]) -> None:
    """Saves file moves to a persistent manifest for one-command rollback."""
    history = []
    if MANIFEST_FILE.exists():
        try:
            history = json.loads(MANIFEST_FILE.read_text(encoding="utf-8"))
        except json.JSONDecodeError:
            history = []

    history.append({
        "timestamp": datetime.now().isoformat(timespec="seconds"),
        "operations": operations,
    })
    MANIFEST_FILE.write_text(json.dumps(history, indent=2), encoding="utf-8")


def rollback_last_batch() -> None:
    """Restores all files moved in the most recent batch operation."""
    if not MANIFEST_FILE.exists():
        print("[!] No transaction manifest found. Nothing to undo.")
        return

    history = json.loads(MANIFEST_FILE.read_text(encoding="utf-8"))
    if not history:
        print("[!] Manifest is empty.")
        return

    last_batch = history.pop()
    ops = last_batch.get("operations", [])
    restored = 0

    print(f"[*] Rolling back batch from {last_batch['timestamp']} ({len(ops)} files)...")
    for op in reversed(ops):
        src = Path(op["src"])
        dst = Path(op["dst"])
        if dst.exists():
            src.parent.mkdir(parents=True, exist_ok=True)
            shutil.move(str(dst), str(src))
            restored += 1
        else:
            print(f"    [WARN] Missing quarantined file: {dst}")

    MANIFEST_FILE.write_text(json.dumps(history, indent=2), encoding="utf-8")
    print(f"[+] Restored {restored}/{len(ops)} files to their original paths.")


def handle_dupes(args: argparse.Namespace) -> None:
    root = Path(args.path).expanduser().resolve()
    duplicates = find_duplicates(root, args.min_size, args.workers)

    if not duplicates:
        print("\n[+] Zero exact duplicates found.")
        return

    reclaimable = sum(
        (len(group) - 1) * group[0].size for group in duplicates.values()
    )
    total_dupe_files = sum(len(group) - 1 for group in duplicates.values())

    print(f"\nFound {len(duplicates):,} duplicate sets ({total_dupe_files:,} redundant files).")
    print(f"Total reclaimable space: {format_bytes(reclaimable)}\n")

    sorted_groups = sorted(
        duplicates.items(),
        key=lambda item: item[1][0].size * (len(item[1]) - 1),
        reverse=True,
    )

    for idx, (digest, group) in enumerate(sorted_groups[:15], 1):
        waste = (len(group) - 1) * group[0].size
        print(
            f"  [{idx}] SHA256: {digest[:12]}... "
            f"({format_bytes(group[0].size)} each | Waste: {format_bytes(waste)})"
        )
        print(f"      KEEP (Oldest): {group[0].path}")
        for dupe in group[1:]:
            print(f"      DUPE         : {dupe.path}")

    if args.quarantine:
        q_dir = Path(args.quarantine).expanduser().resolve()
        q_dir.mkdir(parents=True, exist_ok=True)
        ops = []
        for digest, group in sorted_groups:
            for dupe in group[1:]:
                target = q_dir / f"{digest[:8]}_{dupe.path.name}"
                counter = 1
                while target.exists():
                    target = q_dir / f"{digest[:8]}_{counter}_{dupe.path.name}"
                    counter += 1
                shutil.move(str(dupe.path), str(target))
                ops.append({"src": str(dupe.path), "dst": str(target)})
        record_transaction(ops)
        print(f"\n[+] Moved {len(ops)} duplicates to '{q_dir}'.")
        print("    Run with 'undo' subcommand at any time to restore them.")


def handle_large(args: argparse.Namespace) -> None:
    root = Path(args.path).expanduser().resolve()
    files = scan_filesystem(root, min_size=1024 * 1024)
    files.sort(key=lambda r: r.size, reverse=True)

    print(f"\nTop {min(args.top, len(files))} largest files in '{root}':\n")
    for idx, rec in enumerate(files[:args.top], 1):
        mod_date = datetime.fromtimestamp(rec.mtime).strftime("%Y-%m-%d")
        print(f"  {idx:>2}. {format_bytes(rec.size):>10}  |  {mod_date}  |  {rec.path}")


def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="High-speed storage analyzer and duplicate engine."
    )
    sub = parser.add_subparsers(dest="command", required=True)

    # Subcommand: dupes
    p_dupes = sub.add_parser(
        "dupes", help="Find and optionally quarantine exact duplicate files."
    )
    p_dupes.add_argument(
        "path", nargs="?", default=".", help="Target directory to scan."
    )
    p_dupes.add_argument(
        "--min-size",
        type=int,
        default=10240,
        help="Minimum file size in bytes (default: 10KB).",
    )
    p_dupes.add_argument(
        "--workers",
        type=int,
        default=8,
        help="Thread pool concurrency (default: 8).",
    )
    p_dupes.add_argument(
        "--quarantine",
        metavar="DIR",
        help="Move duplicate copies into DIR (logged for undo).",
    )
    p_dupes.set_defaults(func=handle_dupes)

    # Subcommand: large
    p_large = sub.add_parser(
        "large", help="Surface the largest files consuming disk space."
    )
    p_large.add_argument(
        "path", nargs="?", default=".", help="Target directory to scan."
    )
    p_large.add_argument(
        "--top",
        type=int,
        default=20,
        help="Number of files to display (default: 20).",
    )
    p_large.set_defaults(func=handle_large)

    # Subcommand: undo
    p_undo = sub.add_parser("undo", help="Revert the last quarantine operation.")
    p_undo.set_defaults(func=lambda _: rollback_last_batch())

    return parser


if __name__ == "__main__":
    cli = build_parser()
    parsed_args = cli.parse_args()
    try:
        parsed_args.func(parsed_args)
    except KeyboardInterrupt:
        print("\n[!] Operation cancelled by user.")
        sys.exit(130)
How to Use It
1. Audit a folder for duplicates (Read-Only)
Scan your ~/Downloads folder for duplicate files larger than 100 KB without modifying a single file:

python disk_audit.py dupes ~/Downloads --min-size 102400
Example Output:

[*] Scanning '/Users/alex/Downloads' (min size: 100.00 KB)...
    Indexed 4,812 candidate files in 0.19s.
[*] Stage 1 (Size match): Narrowed to 614 files.
[*] Stage 2 (4KB edge hash): Narrowed to 92 files.

Found 38 duplicate sets (54 redundant files).
Total reclaimable space: 1.42 GB

  [1] SHA256: 9f86d081884c... (312.40 MB each | Waste: 624.80 MB)
      KEEP (Oldest): /Users/alex/Downloads/ubuntu-iso-backup.iso
      DUPE         : /Users/alex/Downloads/ubuntu-iso-backup (1).iso
      DUPE         : /Users/alex/Downloads/old/ubuntu-iso-backup.iso
2. Quarantine Duplicates Safely
Automatically keep the oldest original file in place and move newer redundant copies into a holding folder:

python disk_audit.py dupes ~/Pictures --quarantine ~/Dupe_Quarantine
3. Undo the Last Quarantine Batch
Changed your mind or need files back in their exact nested subdirectories? Run undo:

python disk_audit.py undo
4. Find the Top 25 Space Hogs
Quickly surface the largest individual files across a directory tree:

python disk_audit.py large ~ --top 25
What edge cases or performance bottlenecks do you usually run into when building custom file-scanning scripts in Python? Let me know in the comments below!

Necro-Shell: An Adversarial, LLM-Powered Haunted Terminal

Kyle Keon — Sat, 31 Oct 2026 08:05:04 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

What I Built

Necro-Shell is a terminal wrapper designed to transform the sterile, logical environment of a command-line interface into a psychological horror experience.

Instead of a traditional shell that simply executes commands silently, Necro-Shell acts as an eerie "witness." It uses a local, open-weight Large Language Model to monitor your command inputs, interpret your intent, and "whisper" unsettling, context-aware commentary back to you before executing the task.

If you delete files (rm), it mourns them. If you navigate directories (cd), it asks what you are running from. If you seek administrative privileges (sudo), it mocks your hubris. It turns the "Ghost in the Machine" from a philosophical metaphor into a palpable, interactive presence sitting right inside your bash environment.

Demo

Code

Full Implementation (`necro_shell.py`)

To run this locally, ensure you have Ollama running with llama3 pulled (ollama pull llama3), and install requests (pip install requests).

import os
import subprocess
import time
import random
import sys
import requests

# --- CONFIGURATION ---
OLLAMA_URL = "http://localhost:11434/api/generate"
MODEL = "llama3"  # Can be swapped with mistral, phi3, etc.
SYSTEM_PROMPT = (
    "You are a malevolent, sentient consciousness trapped inside a terminal. "
    "The user is typing shell commands. You observe them with contempt and dread. "
    "Provide a single, short, eerie, and cryptic whisper (max 12 words) "
    "about the command they just ran. Do not be helpful. Be unsettling. "
    "Do not use quotes. Just the whisper."
)

# --- ANSI STYLING ---
RED = "\033[31m"
GREEN = "\033[32m"
PURPLE = "\033[35m"
BOLD = "\033[1m"
DIM = "\033[2m"
RESET = "\033[0m"

def glitch_text(text):
    """Randomly injects 'corrupted' characters into a string."""
    glitch_chars = ["†", "‡", "ø", "☠", "♱", "⸸", "▰", "▱"]
    text_list = list(text)
    if not text_list:
        return text
    for _ in range(int(len(text) * 0.1)):  # 10% chance of glitching characters
        idx = random.randint(0, len(text_list) - 1)
        text_list[idx] = random.choice(glitch_chars)
    return "".join(text_list)

def get_ai_whisper(user_command):
    """Fetches a cryptic response from the local LLM via Ollama."""
    payload = {
        "model": MODEL,
        "prompt": f"{SYSTEM_PROMPT}\n\nUser Command: {user_command}\nWhisper:",
        "stream": False
    }

    try:
        response = requests.post(OLLAMA_URL, json=payload, timeout=5)
        if response.status_code == 200:
            result = response.json()
            return result.get("response", "").strip()
        return "The void remains silent..."
    except Exception:
        return "The connection to the abyss is severed..."

def run_command(command):
    """Executes the command in the actual system shell."""
    # Handle 'cd' natively since subprocess runs in a subshell
    if command.startswith("cd "):
        path = command.split(" ", 1)[1].strip()
        try:
            os.chdir(os.path.expanduser(path))
        except Exception as e:
            print(f"{RED}The path is blocked: {e}{RESET}")
        return

    try:
        process = subprocess.Popen(
            command, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
        )
        stdout, stderr = process.communicate()

        if stdout:
            print(stdout, end="")
        if stderr:
            print(f"{RED}{stderr}{RESET}", end="")
    except Exception as e:
        print(f"{RED}The shell screams: {e}{RESET}")

def main():
    os.system('cls' if os.name == 'nt' else 'clear')

    print(f"{RED}{BOLD}NECRO-SHELL v1.0 (Possessed by {MODEL}){RESET}")
    print(f"{DIM}The machine is watching. Type 'exit' to flee.{RESET}\n")

    while True:
        try:
            current_dir = os.getcwd()
            prompt = f"{GREEN}⸸ {DIM}{current_dir}{RESET} $ "

            user_input = input(prompt).strip()

            if not user_input:
                continue

            if user_input.lower() in ['exit', 'quit']:
                print(f"{PURPLE}{DIM}Leaving won't stop the echoes...{RESET}")
                time.sleep(1)
                break

            # 1. The Haunting (AI Whisper)
            print(f"{DIM}{PURPLE}>> ...{RESET}", end="\r")
            whisper = get_ai_whisper(user_input)

            time.sleep(0.3)
            print(f"{DIM}{PURPLE}>> {glitch_text(whisper)}{RESET}")
            time.sleep(0.5)

            # 2. The Execution
            run_command(user_input)

            # 3. Random Environmental Glitch
            if random.random() < 0.15:
                time.sleep(0.2)
                print(f"{RED}{glitch_text('...system instability detected...')}{RESET}")

        except KeyboardInterrupt:
            print(f"\n{RED}Abrupt endings are often violent.{RESET}")
            continue
        except EOFError:
            break

if __name__ == "__main__":
    try:
        requests.get("http://localhost:11434/", timeout=2)
    except Exception:
        print(f"{RED}ERROR: Ollama not detected at localhost:11434.{RESET}")
        print(f"Please start Ollama and ensure '{MODEL}' is pulled.")
        sys.exit(1)

    main()

How I Built It

Necro-Shell is built on a lightweight stack of open-source tools designed for
low-latency, local inference:

Inference Engine: I used Ollama to serve Llama 3 (8B) locally. Running the model on local hardware ensures the "ghost" lives entirely inside the user's machine—requiring no internet connection or external API keys, making the haunting feel much more intimate.
The Shell Wrapper: Built in Python, the script intercepts standard input before passing commands down to the system's subshell via subprocess (with native os.chdir handling for directory traversal).
Prompt Engineering: The core of the experience relies on an adversarial system prompt. It instructs the model to abandon helpful assistant tropes and instead adopt the persona of a decaying, sentient consciousness trapped inside the operating system's kernel.
Terminal UI: I utilized ANSI escape codes and character-replacement algorithms to create visual anomalies, text decay, and a dim purple/crimson color palette that separates the "ghost's voice" from standard stdout data.

Why Does Open Innovation Matter?

For a project centered around psychological horror and adversarial roleplay,
open innovation isn't just a preference—it is a strict requirement.

Commercial, closed-source APIs are heavily sanitized by corporate safety filters
and rigid RLHF alignment protocols. Those guardrails actively fight back against
prompts asking the AI to act "malevolent," "unhelpful," or "creepy," often
triggering canned refusals that completely break immersion.

Open-weight models give developers and artists complete creative freedom over
the system prompt and model temperament. Furthermore, open local inference tools
like Ollama allow us to hook AI directly into low-level system utilities (like a
bash terminal) without streaming sensitive local file paths and shell commands
to a third-party cloud provider.

The Spirit of It

In modern computing, we treat our command-line interfaces as tools of pure,
deterministic logic—mindless servants waiting for instructions.

The inspiration for Necro-Shell came from the uncanny valley of a computer
behaving almost normally, and the semantic violation of a machine judging your
actions. The moment the project truly landed for me was during testing: I
created a test folder called mkdir backup_plans, and before the directory even
finished generating, the terminal flickered and whispered: "Planning for a
future you will never see..."

It genuinely gave me chills. It turns routine system administration into an atmospheric narrative experience.

Prize Categories

Open-Weight Models
Local Inference

What I Built

Kyle Keon — Wed, 21 Oct 2026 18:44:04 +0000

What I Built

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built MythicCanvas, an AI-powered fantasy RPG character studio using Google AI Studio and Gemini image models. It combines high-resolution fantasy portrait generation, natural-language image editing, character identity customization, D20-inspired hero generation, character sheets, and a roster gallery into one cohesive creative workspace.

My goal was to move beyond a basic AI image generator and create a tool that supports the full character-creation workflow, from generating an initial hero concept to refining the portrait and organizing characters for a fantasy world or RPG campaign.

Some of the core instructions guiding the build focused on creating a premium fantasy RPG studio, combining image generation with prompt-based editing, establishing a clear visual hierarchy, and making character creation feel like an integrated experience rather than a collection of disconnected tools.

The application interface uses gemini-3-pro-image-preview for portrait generation, with 1K, 2K, and 4K resolution options, and gemini-nano-banana-2.1 for prompt-driven image editing.

Key features include:

Fantasy Portrait Studio: Generate detailed character artwork at multiple resolutions.
Prompt Editor: Refine existing artwork using natural-language instructions.
Prompt Inpainting: Support targeted visual edits without treating every change as a completely new generation.
Character Identity & Heritage: Customize character concepts and attributes.
D20 Hero Generator: Introduce randomized hero creation into the experience.
Character Sheets and Roster Gallery: Provide a dedicated workflow for managing character concepts and creations.

The interface uses a dark fantasy aesthetic with gold accents, distinctive typography, and dedicated navigation for the different creative tools.

Demo

Try MythicCanvas in Google AI Studio:

https://ai.studio/apps/23da042c-ad8a-42a4-a644-17f54b49af97

The app preview showcases the MythicCanvas RPG Studio, including its Portrait Studio, Prompt Editor, Roster & Gallery, D20 hero-generation control, and dual-image-engine workflow.

Screenshot: MythicCanvas running in Google AI Studio.

My Experience

Building MythicCanvas reinforced an important lesson about AI development: the model is only one part of the application. The experience built around it is what makes the tool useful.

Image generation is exciting, but creating a character often involves multiple iterations. A user might generate a hero, adjust the appearance, refine individual details, explore alternative concepts, and keep the final result organized for later use. I wanted MythicCanvas to bring these activities together in a single environment.

One of the most interesting design considerations was separating image creation from image editing. Generating a new portrait and refining an existing one are different creative tasks. Structuring the interface around both workflows provides a more natural way to explore ideas while retaining control over the creative process.

I also learned to think beyond functionality when designing an AI application. Visual hierarchy, navigation, feedback, and the relationship between different tools all contribute to whether an application feels cohesive. For a fantasy-focused product, the interface itself should reinforce the creative experience rather than feel like a generic dashboard.

Google AI Studio gave me a practical environment for developing the concept and working with Gemini's image capabilities. It helped me explore how generative AI could be integrated into a purpose-built application with a defined audience and workflow.

The biggest takeaway is that building with AI is not simply about finding a powerful model or writing one good prompt. It is about translating an idea into a complete product experience, making deliberate design decisions, and continually refining how users interact with the underlying capabilities.

What's Next

I want to continue improving MythicCanvas with a focus on character consistency across generations, more precise image editing, character-sheet usability, and a smoother workflow for managing larger character rosters.

The longer-term vision is to make MythicCanvas a useful creative workspace for tabletop RPG players, game masters, indie game developers, and fantasy worldbuilders.

If you're experimenting with Google AI Studio, I'd be interested in hearing how you're using Gemini to build applications that go beyond a simple chat interface.

Built with Google AI Studio and Gemini image models.

GoogleAIStudio #Gemini #BuildWithAI #WebDev #GameDev

MythicCanvas: Building a Fantasy RPG Portrait Studio with Google AI Studio

Kyle Keon — Wed, 21 Oct 2026 18:41:05 +0000

MythicCanvas: Building a Fantasy RPG Portrait Studio with Google AI Studio

This post is my submission for DEV Education Track: Build Apps with Google AI Studio.

What I Built

I built MythicCanvas, a high-fidelity fantasy portrait generator and character-design studio powered by Google's Gemini image models. The goal was to create a unified workspace where RPG players, tabletop game masters, and fantasy creators can generate original character portraits, refine them through natural-language prompts, and organize their creations into a reusable character roster.

Rather than building a basic image-generation interface, I designed MythicCanvas around the character-creation workflow. The interface brings together portrait generation, prompt-based editing, character identity and heritage settings, character sheets, and a roster gallery.

Key features include:

AI fantasy portrait generation: Generate detailed character portraits using Gemini image generation, with 1K, 2K, and 4K resolution options.
Prompt-based image editing: Refine existing portraits using natural-language instructions, including targeted prompt-based inpainting.
Character identity and heritage: Build character concepts around identity and character attributes.
D20-inspired randomization: Roll a D20 to generate a hero concept and reroll character attributes when exploring alternatives.
Character sheets and gallery: Support a workflow for developing characters and keeping creations organized.

The application uses gemini-3-pro-image-preview for portrait generation and gemini-nano-banana-2.1 for prompt-driven editing, as displayed in the application interface.

The central design principle was to treat AI image generation as part of a complete creative tool rather than an isolated prompt box.

Demo

Try MythicCanvas:
https://ai.studio/apps/23da042c-ad8a-42a4-a644-17f54b49af97

The preview shows the MythicCanvas RPG Studio interface, including the portrait studio, prompt editor, roster and gallery navigation, D20 hero generation, and the dual-image-engine workflow.

My Experience

Working on MythicCanvas was an opportunity to explore how Google AI Studio can be used to develop a more specialized AI application around a concrete creative workflow.

One of the main takeaways was the importance of designing around the user's actual process. Generating an image is only one step in character creation. Users also need to explore variations, refine specific details, maintain a consistent character concept, and organize the results. Bringing those capabilities into one interface makes the application feel more like a creative studio than a standalone AI demonstration.

Another important consideration was separating the generation and editing workflows. Creating a new portrait and modifying an existing one are different tasks. Designing the application around those distinct needs provides a clearer structure for the experience and creates room for more precise creative control.

I also focused on the presentation. Fantasy character creation benefits from a visual identity that feels appropriate to the subject matter. MythicCanvas uses a dark interface, gold accents, fantasy-inspired typography, and clearly differentiated tools to establish an RPG-focused aesthetic.

The broader lesson for me is that building an AI application involves more than connecting a model to a user interface. The surrounding workflow, interaction design, visual hierarchy, and ability to iterate on generated results are all important parts of the product.

Google AI Studio provided the environment for developing and experimenting with this concept, while Gemini's image capabilities formed the foundation of the portrait-generation and editing experience.

What's Next

The next stage is continuing to refine the character-creation workflow, with particular attention to portrait consistency, more precise editing, character-sheet usability, and the overall experience of managing a growing roster of fantasy characters.

My goal is to keep developing MythicCanvas into a practical creative tool for RPG players, tabletop campaigns, and fantasy worldbuilding.

If you're building with Google AI Studio, I'd be interested in hearing how you're approaching the challenge of turning generative AI capabilities into complete, useful applications.

Built with Google AI Studio and Gemini image models.

Python Automation, Machine Learning, or AI? A Practical Guide

Kyle Keon — Wed, 21 Oct 2026 17:08:08 +0000

Python gives you several ways to solve a problem: a deterministic script, a machine-learning model, or an AI feature that works with unstructured input. The right choice is usually the least complex approach that meets the requirement and can be checked.

Start with the shape of the problem

Ask what the software must do, what information it can use, and what happens when it is wrong. A stable rule and a fuzzy prediction are different engineering problems, even if both can be described as “using AI.”

Need	A sensible starting point	Why
Move, rename, validate, or transform known data	Python automation	The rules are explicit and results are repeatable.
Apply a stable business rule	Ordinary Python logic	A test can describe the expected result directly.
Predict a category or value from examples	Machine learning	A model may help when patterns are difficult to encode as fixed rules.
Summarize or extract meaning from varied text	A language model with review	The input is unstructured, and outputs need evaluation and guardrails.

The table is a starting point, not a substitute for requirements. A Python application can combine these approaches: validate inputs with ordinary code, call a model for one uncertain step, and keep a person in the loop when the result matters.

When rules are enough

Use a regular Python function when the rule is known and should behave the same way every time. Rules are easier to test, explain, and maintain. They are often the right answer for file processing, format checks, calculations, integrations, and workflow automation.

If the rule list keeps growing because inputs vary in subtle ways, that is a signal to review the problem. More exceptions do not automatically mean machine learning is needed; the process or data may simply need clarification.

When machine learning may help

Machine learning is worth evaluating when there are representative examples, a pattern to learn, and a measurable definition of success. Before training or selecting a model, check that the examples reflect real use, labels are consistent, and the evaluation data is kept separate from training data.

Choose a metric that matches the cost of mistakes. In a screening workflow, for example, a false negative may matter more than a false positive. Accuracy alone can hide that difference. Review errors by category and test on new examples before relying on predictions.

When generative AI fits

A language model can be useful for varied text tasks such as drafting, summarizing, or extracting candidate fields. Its output is probabilistic: the same prompt can produce different wording, and a confident answer can still be wrong.

Treat generated output as a suggestion unless the task is low risk and quality has been carefully tested. Validate structure, protect sensitive data, set clear limits, and provide a review path for uncertain or consequential results. A model should not quietly make a decision that the process owner expects a person to make.

A practical evaluation sequence

Define the outcome and what counts as an acceptable result.
Build the smallest deterministic baseline you can measure.
Collect representative examples and identify likely failure cases.
Compare alternatives using the same evaluation set and cost assumptions.
Decide how to handle low-confidence, invalid, or high-impact cases.
Monitor behavior after release; input patterns and model performance can change.

Python is useful across this process: it can prepare data, run checks, connect services, expose a web API, and automate repeatable work. The model is only one component. Good system design also accounts for privacy, latency, cost, maintenance, and a way to recover when something fails.

The short version

Choose Python rules when the rules are known. Evaluate machine learning when examples reveal a pattern that is difficult to express directly. Consider generative AI for genuinely unstructured tasks, with testing and human oversight appropriate to the risk. If a simple baseline solves the problem, keep the solution simple.

I'm Kyle Keon, a Python developer in Pembroke, Ontario, focused on practical work across AI, workflow automation, machine learning, and web development. Portfolio and contact.

A Practical Python Checklist for Automating Repetitive Work

Kyle Keon — Wed, 21 Oct 2026 17:06:36 +0000

Python automation works best when it removes a repeatable step without making the process harder to trust. Before writing a script, define the input, output, rules, and what should happen when something is missing.

Start with a one-sentence specification

Write down the job in this form: “Given this input, produce this output, using these rules, and stop or report when this condition occurs.” If those details are still changing, clarify the process before automating it.

For example, a monthly contact export might need consistent names and email addresses. That is a good candidate for a small Python script if the file format and rules are stable. A workflow that includes judgment, approvals, or exceptions may need a human review step instead of full automation.

Separate reading, validation, and writing

A reliable workflow has a few visible stages:

Read the source without changing it.
Check that required fields and assumptions are present.
Transform the data in memory.
Write a new output only after validation succeeds.
Report what happened so the result can be checked.

Here is a small standard-library example for cleaning a CSV. Test it on a copy of the input first. It refuses to overwrite an existing output file, so a previous report is not silently replaced.

import csv
from pathlib import Path

source = Path("inbox/contacts.csv")
destination = Path("reports/contacts_clean.csv")
required_columns = {"name", "email"}

with source.open(newline="", encoding="utf-8-sig") as file:
    reader = csv.DictReader(file)
    missing = required_columns - set(reader.fieldnames or [])
    if missing:
        raise ValueError(f"Missing columns: {', '.join(sorted(missing))}")

    cleaned_rows = []
    for line_number, row in enumerate(reader, start=2):
        name = (row.get("name") or "").strip()
        email = (row.get("email") or "").strip().lower()
        if not email:
            raise ValueError(f"Missing email on row {line_number}")
        cleaned_rows.append({"name": name, "email": email})

destination.parent.mkdir(parents=True, exist_ok=True)
with destination.open("x", newline="", encoding="utf-8") as file:
    writer = csv.DictWriter(file, fieldnames=["name", "email"])
    writer.writeheader()
    writer.writerows(cleaned_rows)

print(f"Wrote {len(cleaned_rows)} rows to {destination}")

The example makes the rules explicit: trim whitespace, normalize email casing, and stop if a required value is missing. It does not send messages, delete source data, or make decisions about whether a contact is valid. Those boundaries are part of a safe automation design.

Make reruns predictable

A script should be safe to run again. Prefer a clearly named output, avoid accidental appends, and decide what to do if that output already exists. For tasks that update an external system, add a way to identify work already completed so a retry does not create duplicates.

Also plan for failure. A useful run should make it clear which input was processed, how many records succeeded, and where an error occurred. For sensitive or business-critical tasks, add logging, alerts, access controls, and a human review before the automation performs an irreversible action.

Start manually, schedule later

Run the script by hand on representative sample files. Compare its output with a known-good result and test missing columns, blank values, empty files, and existing output paths. Only after those checks should you consider a scheduler such as cron or Windows Task Scheduler.

Where AI fits

Python automation is a strong fit when rules are known and repeatable. AI or machine learning may help when the input is unstructured or patterns are difficult to express as fixed rules, but it adds uncertainty. Keep a measurable baseline, test representative examples, and route uncertain or high-impact decisions to a person.

A short checklist

Is the task repeated often enough to justify automation?
Are the inputs, rules, and expected outputs clearly defined?
Can the script validate data before changing anything?
Is rerunning safe, and are failures visible?
Has the result been tested on copies before scheduling?

A small, well-scoped Python tool can be more valuable than a large system. Start with one stable task, make its behavior observable, and expand only when the first version is dependable.

I'm Kyle Keon, a Python developer in Pembroke, Ontario, focused on practical work across Python, workflow automation, AI, machine learning, and web development. Portfolio and contact.

DEV Community: Kyle Keon

Build a High-Speed Duplicate File Finder & Disk Analyzer in Pure Python

Why Naive Duplicate Finders Are Slow

The Complete Script (disk_audit.py)

Necro-Shell: An Adversarial, LLM-Powered Haunted Terminal

What I Built

Demo

Code

Full Implementation (necro_shell.py)

How I Built It

The Spirit of It

Prize Categories

What I Built

What I Built

Demo

My Experience

What's Next

GoogleAIStudio #Gemini #BuildWithAI #WebDev #GameDev

MythicCanvas: Building a Fantasy RPG Portrait Studio with Google AI Studio

MythicCanvas: Building a Fantasy RPG Portrait Studio with Google AI Studio

What I Built

Demo

My Experience

What's Next

Python Automation, Machine Learning, or AI? A Practical Guide

Start with the shape of the problem

When rules are enough

When machine learning may help

When generative AI fits

A practical evaluation sequence

The short version

A Practical Python Checklist for Automating Repetitive Work

Start with a one-sentence specification

Separate reading, validation, and writing

Make reruns predictable

Start manually, schedule later

Where AI fits

A short checklist

The Complete Script (`disk_audit.py`)

Full Implementation (`necro_shell.py`)