Forem: Aggrey Paintsil Ishmeal

I Built an AI That Answers Every Question With HTTP 418 — RFC 2324 Compliant

Aggrey Paintsil Ishmeal — Sun, 12 Apr 2026 06:36:01 +0000

This is a submission for the DEV April Fools Challenge

What I Built

Meet DecisionBrew AI — the world's first Enterprise Teapot Intelligence Platform, powered by Google Gemini and RFC 2324.

You type any question. A life-changing question. A career question. A pineapple-on-pizza question. DecisionBrew AI runs it through a sophisticated 6-step AI reasoning pipeline — parsing your semantic intent layer, heating water to optimal brew temperature, cross-referencing the global tea-leaf database, running 847 parallel tannin models — and after all that computation, delivers its verdict:

418 — I'm a Teapot.

Every single time. Brew Confidence: 17%. Useful: No. Actionable: Absolutely not.

The "Consult a Real Human Instead" button also returns a 418. We are in a loop now. The tea has gone cold.

Demo

🫖 Live App: https://decision-brew-ai.vercel.app

Code

GitHub: https://github.com/aggreypaintsil168/decision-brew-ai

The entire app is a single index.html — no build step, no dependencies, no framework.

The core of the joke lives in the system prompt sent to Gemini: Gemini then invents tea-jargon analysis like "tannin gradient overflow", "steep confidence interval: collapsed", and "infusion entropy: critical" — all wrapped in a fake enterprise dashboard with animated reasoning steps, live metrics, and a consultation history log.

How I Built It

Stack:

Vanilla HTML/CSS/JS — zero dependencies, zero build step, one file
Google Gemini 2.0 Flash API — prompt-engineered as a sentient teapot
Vercel Serverless Function — to proxy the API key safely in production

The interesting engineering challenge was making the uselessness feel premium. The fake reasoning pipeline animates step-by-step with real elapsed times. The dashboard tracks metrics — brews today, average confidence (always ~17%), total 418s served, and a running consultation history. It looks like a serious product. It is not.

The system prompt was the most important part. Constraining Gemini to respond only in JSON, only with confidence between 12–23%, and always in the voice of a dramatically self-aware teapot took several iterations. Temperature set to 1.1 for maximum absurdity.

DecisionBrew AI is a love letter to that joke. Every single interaction ends in a 418. The entire product exists to serve that status code with maximum dramatic flair. HTCPCP IYKYK.

On the Google AI side: Gemini 2.0 Flash is not decoration here — it is the entire engine of the absurdity. Without the API, you just have a button that says "418". With it, you get a sentient teapot that tells you your career question has a "kettle alignment score of 0.003" and that "the quantum brew field destabilizes upon observation." That is the joke. Gemini makes it different and funnier every single time.

418 — I'm a teapot. This project solves zero real-world problems. Built with love, Earl Grey, and deep respect for useless internet standards.

I Built an AI That Answers Every Question With HTTP 418 — RFC 2324 Compliant

Aggrey Paintsil Ishmeal — Sun, 12 Apr 2026 06:28:42 +0000

This is a submission for the DEV April Fools Challenge

What I Built

Meet DecisionBrew AI — the world's first Enterprise Teapot Intelligence Platform, powered by Google Gemini and RFC 2324.

418 — I'm a Teapot.

Every single time. Brew Confidence: 17%. Useful: No. Actionable: Absolutely not.

The "Consult a Real Human Instead" button also returns a 418. We are in a loop now. The tea has gone cold.

Demo

🫖 Live App: https://decision-brew-ai.vercel.app

Code

GitHub: https://github.com/aggreypaintsil168/decision-brew-ai

The entire app is a single index.html — no build step, no dependencies, no framework.

How I Built It

Stack:

Vanilla HTML/CSS/JS — zero dependencies, zero build step, one file
Google Gemini 2.0 Flash API — prompt-engineered as a sentient teapot
Vercel Serverless Function — to proxy the API key safely in production

DecisionBrew AI is a love letter to that joke. Every single interaction ends in a 418. The entire product exists to serve that status code with maximum dramatic flair. HTCPCP IYKYK.

418 — I'm a teapot. This project solves zero real-world problems. Built with love, Earl Grey, and deep respect for useless internet standards.

I Had Every Advantage in My CS Programme

Aggrey Paintsil Ishmeal — Sat, 04 Apr 2026 21:04:07 +0000

That's Exactly the Problem

This is a submission for the 2026 WeCoded Challenge: Echoes of Experience

The first time I walked into a university computer lab in Ghana, I didn't count the room.

That's the point.

I walked in, found a seat, opened my laptop, and got to work. I didn't calculate my odds. I didn't wonder if I belonged. I didn't brace for anything. The room was full of people who looked like me, spoke like me, had been told — implicitly, repeatedly, since childhood — that a future in technology was a reasonable thing for someone like me to want.

I had no idea, at the time, that this ease was a privilege. I thought it was just Tuesday.

It took watching my female classmates navigate the same room — the same lectures, the same group projects, the same career fairs — to understand that we were not having the same experience at all.

What I Started Noticing

Out of thirty-one students in my first Introduction to Programming class, four were women. I didn't notice that either, at first. It just seemed like the natural shape of things.

But then I started paying attention.

I noticed that when a woman answered a question correctly, there was sometimes a half-second pause before the response — a beat of mild surprise that was never there when I answered. I noticed that in group projects, the unspoken assumption was that the women would handle documentation and presentation — the "softer" edges of the work — and that nobody had decided this consciously. It had simply settled that way, like sediment.

I noticed that when one of my female classmates mentioned she wanted to go into embedded systems, someone said "that's unusual for a girl" — and the room didn't push back. I didn't push back. I said nothing.

That silence has bothered me ever since.

The Names I Wasn't Taught

Here is something I learned outside of my CS curriculum, in the corners of late-night research:

The first algorithm ever written was by a woman named Ada Lovelace — in 1843. Grace Hopper invented the compiler. Katherine Johnson's calculations put humans on the moon. The spread-spectrum technology underpinning modern WiFi traces back to a patent held by Hedy Lamarr. Radia Perlman invented the spanning tree protocol that makes the internet function. Fei-Fei Li created ImageNet and shaped the entire trajectory of modern AI.

I was not taught any of these names in school.

I was handed a field that women helped build, and I was taught to think of it as having been built without them. Without meaning to, without anyone telling me explicitly, I absorbed a version of this discipline where women were guests rather than founders.

That is not a neutral thing to absorb. It shapes how you see your colleagues. It shapes how you treat them. It shapes the rooms you build when it becomes your turn to build them.

What Being an Ally Actually Looks Like (I'm Still Learning)

I want to be careful here, because "allyship" can become a word men use to feel good about themselves without changing much.

What I have tried to do — imperfectly, inconsistently — is smaller and more specific than a word:

Speak up in the moment. When someone says something dismissive to a female classmate, the window to respond is about three seconds before the conversation moves on and the moment calcifies into accepted reality. I have missed that window more times than I've caught it. But I am getting faster.

Give credit loudly. In group settings, when a woman's idea gets absorbed into the conversation without attribution, I name it: "That was her idea — can we go back to what she said?" This feels small. It is not small.

Stop explaining things that weren't asked for. I have caught myself mid-sentence explaining a concept to a female classmate who neither needed nor requested it. That reflex is worth examining. Repeatedly.

Learn the names. Ada. Grace. Katherine. Hedy. Radia. Fei-Fei. I say them in conversations. I send them to younger students. I refuse to let the history stay edited.

Ghana, and Why This Conversation Belongs Here Too

Gender equity in tech is often framed as a Silicon Valley problem. Pay gaps, pipeline statistics, diversity dashboards. But the ceiling exists here too — it just has different walls.

In Ghana, it lives in the guidance counsellor who steers a girl brilliant at mathematics toward accounting instead of CS — not out of malice, but out of a world that has offered women fewer safe paths. It lives in families who fund their sons' CS degrees without question and gently suggest their daughters choose something "more practical." It lives in the casual import of tech bro culture — from YouTube, Twitter, startup mythology — landing here without the vocabulary that elsewhere has at least begun to name the problem.

I am not separate from this. I was shaped by the same environment. Some of the biases I'm describing are ones I still find in myself when I look carefully enough. That's not comfortable to write. But I think it's more useful than pretending I arrived at allyship fully formed.

Why I Built What I Built

For the Frontend Art prompt of this challenge, I built an interactive canvas piece called "She Compiles the Stars" — 1,800 particles that assemble into a woman's silhouette, a glass ceiling that fractures and shatters when you click it, and the names of six pioneers encoded into the experience.

I built it because I wanted to do something more than observe. Code is my medium. And I thought: if I can use this skill to say these women existed, this ceiling exists, and it can be broken — then that is worth the time.

I also built it to prove something to myself. That I could engage with this subject not as an outsider looking in, but as someone who understands that gender equity in tech is not a women's problem to solve. It is a problem that men — especially men with the ease of walking into rooms without counting them — have both the responsibility and the ability to help fix.

What I Want Other Men to Hear

If you are a man in tech and you have never thought much about this: I'm not here to make you feel guilty. Guilt is not useful.

But I want to ask you to do what I did: start noticing.

Notice who speaks in your meetings and who gets heard. Notice who gets assigned which tasks. Notice who you explain things to unprompted. Notice whose names are missing from the history you were taught.

Then ask yourself what you could do differently. Not perfectly. Not all at once. Just — differently.

The room was built for us. That means we have more power than most to decide what the next room looks like.

To the Women in CS Who Are Still Counting

I see you counting the room when you walk in. I understand now why you do.

I can't promise the count will change as fast as it should. But I can promise that some of us are paying attention — and that we are trying, however imperfectly, to build the room you deserve to walk into without counting.

Written from Accra, Ghana, 2026.

I also submitted a Frontend Art piece for this challenge — "She Compiles the Stars," an interactive particle animation. You can find it here - [https://codepen.io/Aggrey-Paintsil/pen/GgjGwGJ]

A Particle Art Tribute to Gender Equity in Tech

Aggrey Paintsil Ishmeal — Sat, 04 Apr 2026 20:50:58 +0000

She Compiles the Stars

This is a submission for the 2026 WeCoded Challenge: Frontend Art

Show us your Art

Live demo: [https://codepen.io/Aggrey-Paintsil/pen/GgjGwGJ]

Inspiration

I am a computer science student in Ghana, and when I think about gender equity in technology, I don't think of it as a distant Western conversation. I think about the women in my own classrooms — brilliant, capable, often the only woman in the room — who have to work twice as hard to be taken half as seriously. I think about the pioneers whose names we rarely learn in school. And I think about the ceiling: invisible, but very real.

That is what this piece is about.

"She Compiles the Stars" is a three-act interactive art experience built entirely in vanilla JavaScript and HTML5 Canvas — no frameworks, no libraries, just code.

The Three Acts

Act I — The Constellation Forms
1,800 particles drift across a deep space background and slowly assemble into the silhouette of a woman, fist raised. Each particle finds its place, the way every woman in tech has had to find hers — often starting scattered, often starting alone, but always moving toward something.

Act II — She Reaches Beyond the Ceiling
A glass ceiling hovers above her — translucent, almost invisible, but unmistakably there. The border frame draws on Kente cloth geometry, a nod to my Ghanaian heritage and a reminder that this story of resilience belongs to women everywhere, not just in Silicon Valley.

Act III — The Ceiling Breaks
Click "shatter the ceiling" and golden cracks radiate outward. Glass shards explode downward. The particles scatter free. The stars belong to everyone now.

The Pioneers

Encoded into the piece are six women whose contributions built the technology world we live in — yet whose names are rarely taught:

Ada Lovelace — wrote the first algorithm in 1843, before computers existed
Grace Hopper — invented the compiler and made programming accessible to humans
Katherine Johnson — calculated the trajectories that sent humans to the moon
Hedy Lamarr — co-invented spread-spectrum communications, the foundation of WiFi and Bluetooth
Radia Perlman — invented the spanning tree protocol that makes the internet function
Fei-Fei Li — created ImageNet and shaped the entire field of modern AI

The counter in the top corner reads 6 — six pioneers shown here. The real number is countless.

Why Afrofuturism?

I made a deliberate choice to root this piece in an Afrofuturist aesthetic — dark cosmic backgrounds, warm gold and rust tones drawn from earth and fire, geometric patterns inspired by Kente weaving. Afrofuturism imagines futures where African and diasporic people are not erased but centred. That same imagination is what gender equity in tech demands: not just adding women to existing systems, but building futures where they were never excluded to begin with.

The typography pairs Cormorant Garamond (elegant, literary, the serif of manifestos) with DM Mono (code, terminals, the language of builders). Together they say: this is both a story and a system.

What I Built With

HTML5 Canvas — particle system, silhouette targeting, nebula backgrounds, starfield, glass shatter physics
SVG — Kente-inspired geometric border frame with tiling patterns
Vanilla JavaScript — custom particle engine (1,800 particles with individual targets), procedural crack generation, shard physics with gravity, film grain via ImageData, counter animation, 3-act state machine
CSS — custom cursor, staggered reveal animations, Cormorant Garamond + DM Mono font pairing
Zero dependencies — no libraries, no build tools, one single HTML file

My Code

github https://github.com/aggreypaintsil168/she-compiles-the-stars.git

Or view the full source on GitHub / CodePen

A Note

I used AI tooling to help develop parts of this submission — in keeping with the challenge rules. The concept, the meaning, the Afrofuturist direction, the choice to name these specific pioneers, the decision to ground it in my experience as a student in Ghana — those are entirely my own.

The glass ceiling is not abstract to me. This piece is my way of coding against it.

Cover image generated from a screenshot of the live piece.

✨ Built with Google Gemini: PaperLens AI — Chat With Research Papers

Aggrey Paintsil Ishmeal — Fri, 06 Mar 2026 04:46:18 +0000

This is a submission for the Built with Google Gemini: Writing Challenge

What I Built with Google Gemini

As a computer science student working on research projects, I often face the same problem: research papers are difficult and time-consuming to understand. Papers can be long, technical, and full of complex equations, making it hard to quickly extract the key ideas.

To solve this, I built PaperLens AI, an application that allows users to upload a research paper PDF and interact with it using AI.

The app automatically:

Extracts text from the uploaded research paper
Splits the document into semantic chunks
Creates embeddings for each chunk using Google Gemini embeddings
Retrieves the most relevant sections of the paper
Uses Gemini to answer questions about the paper

In simple terms, PaperLens AI lets users chat with research papers.

For example, users can ask questions like:

What is the research gap in this paper?
What dataset was used?
What are the limitations of the method?

The AI then finds the most relevant sections of the paper and generates an answer based on those sections.

Architecture of the System

The system uses a simple Retrieval Augmented Generation (RAG) pipeline.

Research Paper PDF
        ↓
Text Extraction (PyPDF2)
        ↓
Chunking
        ↓
Gemini Embeddings
        ↓
Similarity Search
        ↓
Gemini generates answer

Technologies used:

Python
Streamlit (UI)
Google Gemini API
NumPy / Scikit-learn
Vector similarity search

The goal was to create something lightweight but powerful enough to help students quickly understand complex research.

Demo

Here is the interface of PaperLens AI.

aggreypaintsil168 / paperlens-ai

Research papers are difficult and time-consuming to understand. Papers can be long, technical, and full of complex equations, making it hard to quickly extract the key ideas.

📄 PaperLens AI

Chat With Research Papers Using Google Gemini

🚀 Overview

PaperLens AI is an AI-powered application that allows users to upload research papers and interact with them conversationally.

Instead of reading long academic papers line by line, users can ask questions like:

What is the research gap in this paper?
What dataset was used?
What methodology does the paper propose?
What are the limitations of the study?

PaperLens AI retrieves the most relevant sections of the paper and uses Google Gemini to generate contextual answers.

This transforms static research documents into an interactive knowledge system.

🎥 Demo

Example UI:

Upload Research Paper
↓
Extract + Chunk Paper
↓
Create Embeddings
↓
Ask Gemini

Example query:

What is the research gap of this paper?

Example output:

The research gap addressed by this paper is the inability of
traditional forecasting models to capture both temporal
dependencies and trend

…

View on GitHub

Users can:

Upload a research paper
Extract and chunk the document
Generate embeddings
Ask questions about the paper

Example workflow:

Upload PDF
→ Extract + Chunk Paper
→ Create Embeddings
→ Ask Gemini

Example question:

What is the research gap in this paper?

The system retrieves relevant sections and Gemini generates an explanation.

(If deployed, the Cloud Run app would be embedded here.)

What I Learned

This project taught me several technical and conceptual lessons.

1. How Retrieval-Augmented Generation Works

Before this project, I had only read about RAG systems. Implementing it myself helped me understand how modern AI assistants work internally.

Instead of sending an entire document to the model, we:

Convert text into embeddings
Store them as vectors
Retrieve the most relevant pieces of text
Send those pieces to the AI model

This dramatically improves both accuracy and efficiency.

2. Building AI Applications Requires More Than Just Calling an API

The real engineering work was in:

Text chunking
Embedding generation
Similarity search
Prompt engineering

These components are what transform a basic model call into a useful application.

3. Debugging AI Infrastructure

While building PaperLens AI I encountered several issues, including:

API authentication errors
Deprecated Gemini models
Embedding model changes
API quota limitations

Debugging these issues taught me a lot about how real AI systems evolve quickly, and why developers must constantly adapt to new APIs and model updates.

4. Building AI Tools for Research

As someone interested in machine learning and research, building this project made me realize how powerful AI can be for assisting with scientific work.

Tools like this could help students:

Understand research papers faster
Identify research gaps
Generate ideas for new research directions

Google Gemini Feedback

Overall, Google Gemini made it relatively easy to build a powerful AI application.

What worked well

The embedding capabilities and text generation features made it possible to build a full RAG pipeline with relatively little code.

Gemini was particularly good at:

Explaining complex technical concepts
Summarizing research sections
Answering contextual questions about documents

Where I ran into friction

One challenge I encountered was related to model changes and deprecations.

During development, some models referenced in earlier documentation were no longer available, which required updating the application to use newer Gemini models.

Another challenge involved API quota limits, which temporarily prevented some requests from completing during testing.

These issues highlighted how quickly AI platforms evolve and the importance of keeping projects updated with the latest SDKs and models.

What I’d like to see improved

Two improvements that would make Gemini development even better are:

clearer versioning for model releases
easier visibility into quota usage during development

These would help developers avoid unexpected errors while building applications.

What’s Next

PaperLens AI is just the beginning.

Future improvements could include:

Multi-paper comparison
Automatic research gap detection
Citation extraction
Integration with academic databases

Ultimately, I’d love to turn PaperLens AI into a tool that helps students and researchers navigate the growing volume of scientific literature.

Final Thoughts

This project reminded me that the most exciting part of AI development isn’t just the models themselves — it’s how we apply them to real problems.

For students and researchers, understanding complex papers is often a major barrier. With tools like Google Gemini, we can start building systems that make knowledge more accessible.

And that’s something worth building.

I Built a Windows-First Repo Explainer Using GitHub Copilot CLI

Aggrey Paintsil Ishmeal — Tue, 10 Feb 2026 13:43:23 +0000

This is a submission for the

GitHub Copilot CLI Challenge

🧠 What I Built

I built RepoBuddy, a Windows-first Python CLI tool that helps beginners understand GitHub repositories directly from the terminal.

As a Windows user, I often find onboarding into new repositories difficult because:

Documentation assumes macOS or Linux
It’s unclear which files to read first
Setup and run instructions are incomplete or scattered

RepoBuddy solves this by:

Reading a repository’s folder structure and README
Sending that context to GitHub Copilot CLI
Returning:
- A plain-English explanation of what the repository does
- Key folders and files to focus on
- Beginner-friendly Windows PowerShell setup and run instructions

All of this happens inside the terminal, without opening an IDE.

▶️ Demo

🔗 GitHub Repository

👉 https://github.com/aggreypaintsil168/repobuddy

Example commands


powershell
# Explain the current repository
python src\repobuddy.py explain .

# Generate Windows PowerShell run instructions
python src\repobuddy.py how-to-run .
What the demo shows
GitHub Copilot CLI actively analyzing the repository

Copilot CLI reading files and directory structure

Structured explanations rendered directly in the terminal

Windows PowerShell-specific setup and run steps

📸 Tip:
I’ve included a short terminal demo (screenshots
![ ](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/e78xhh6qptrj45xhwa3z.png)) showing Copilot CLI in action to make the workflow easy to see.

🤖 My Experience with GitHub Copilot CLI
RepoBuddy uses GitHub Copilot CLI directly as an AI backend, not as an IDE autocomplete tool.

The application invokes Copilot CLI programmatically from Python:

python
Copy code
subprocess.run(
    ["copilot"],
    input=prompt.encode("utf-8"),
    stdout=subprocess.PIPE,
    stderr=subprocess.STDOUT,
)
My workflow was:

Collect repository context (folder structure + README)

Build a structured, Windows-focused prompt

Send the prompt to Copilot CLI via standard input

Render Copilot’s response in real time using Rich for better terminal UX

Copilot CLI:

Inspected directories

Read repository files

Reasoned about project intent

Generated explanations and Windows PowerShell run steps dynamically

Seeing Copilot CLI’s activity directly in the terminal made the AI’s reasoning transparent and easy to demo.
This experience showed me that Copilot CLI can be used as a scriptable developer assistant, not just an autocomplete tool.

💬 Let’s Discuss
I’d love feedback or questions in the comments:

How do you currently understand new repositories?

Would a tool like this help your onboarding workflow?

How else have you used GitHub Copilot CLI outside an IDE?

Thanks for reading — and thanks to the Dev Community Organisers for running this challenge

Forem: Aggrey Paintsil Ishmeal

I Built an AI That Answers Every Question With HTTP 418 — RFC 2324 Compliant

What I Built

Demo

Code

How I Built It

I Built an AI That Answers Every Question With HTTP 418 — RFC 2324 Compliant

What I Built

Demo

Code

How I Built It

I Had Every Advantage in My CS Programme

That's Exactly the Problem

What I Started Noticing

The Names I Wasn't Taught

What Being an Ally Actually Looks Like (I'm Still Learning)

Ghana, and Why This Conversation Belongs Here Too

Why I Built What I Built

What I Want Other Men to Hear

To the Women in CS Who Are Still Counting

A Particle Art Tribute to Gender Equity in Tech

She Compiles the Stars

Show us your Art

Live demo: [https://codepen.io/Aggrey-Paintsil/pen/GgjGwGJ]

Inspiration

The Three Acts

The Pioneers

Why Afrofuturism?

What I Built With

My Code

A Note

✨ Built with Google Gemini: PaperLens AI — Chat With Research Papers

What I Built with Google Gemini

Architecture of the System

Demo

aggreypaintsil168 / paperlens-ai

Research papers are difficult and time-consuming to understand. Papers can be long, technical, and full of complex equations, making it hard to quickly extract the key ideas.

📄 PaperLens AI

Chat With Research Papers Using Google Gemini

🚀 Overview

🎥 Demo

What I Learned

1. How Retrieval-Augmented Generation Works

2. Building AI Applications Requires More Than Just Calling an API

3. Debugging AI Infrastructure

4. Building AI Tools for Research

Google Gemini Feedback

What worked well

Where I ran into friction

What I’d like to see improved

What’s Next

Final Thoughts

I Built a Windows-First Repo Explainer Using GitHub Copilot CLI

🧠 What I Built

▶️ Demo

Example commands