DEV Community: Kyle Keon

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.