DEV Community: Slevin Cordeiro

ProofPocket: I Built an Open-Weight AI Agent That Turns Paperwork Chaos into Progress

Slevin Cordeiro — Mon, 26 Oct 2026 01:18:10 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 3: Slow and Steady

What I Built

Meet ProofPocket — an open-weight AI paperwork agent built around a simple idea: people shouldn't have to spend hours organizing documents when AI can handle the repetitive work.

Whether you're preparing a scholarship application, organizing internship documents, or gathering paperwork for a program, the process is often the same: read the requirements, search through files, figure out what's missing, rename documents, and double-check everything.

ProofPocket turns this tedious process into a structured, reviewable workflow.

Here's what it does:

Understands requirements: Converts application instructions into a structured checklist.
Finds relevant evidence: Matches uploaded documents to requirements and explains why each match was suggested.
Flags missing information: Identifies missing documents, incomplete evidence, and ambiguous matches instead of blindly marking everything complete.
Organizes the paperwork: Suggests descriptive filenames and creates a downloadable application pack.
Keeps humans in control: Lets users review the results, correct mistakes, and approve the final pack before downloading it.

The goal isn't to replace human judgment. It's to eliminate the repetitive work that gets in the way of it.

Instead of manually checking every document against every requirement, users can focus on the exceptions that actually need their attention.

Demo

Code

Repository: ProofPocket on GitHub

The project is designed to be open source, with a modular AI architecture so developers can inspect, modify, and extend how document analysis works.

How I Built It

ProofPocket combines a modern web application with an open-weight AI model and a structured document-processing pipeline.

The technology stack:

Next.js and TypeScript: The web application, dashboard, document upload workflow, and review interface.
Google Gemma: The open-weight AI model used to interpret requirements, extract structured information from document text, and reason about potential evidence matches.
MongoDB Atlas: Stores project metadata, requirements, extracted fields, and relationships between documents and evidence.
Render: Hosts the application and its backend.
Sentry: Provides error monitoring and visibility into processing failures.

The processing pipeline separates deterministic operations from AI reasoning.

First, uploaded files are validated and their text is extracted using suitable document-processing tools. The extracted text and application instructions are then passed through structured analysis. Gemma helps interpret the requirements and suggest relationships between available documents and required evidence.

The application validates the resulting structured data and presents each match with its supporting evidence. When the evidence is insufficient or ambiguous, the requirement is sent for human review instead of being automatically marked as satisfied.

Finally, the user can review the proposed document pack and generate a ZIP containing organized files and reports.

This separation is important: the model handles language and ambiguity, while deterministic code handles validation, file operations, and output generation.

The application is designed to support a configured Gemma inference endpoint rather than requiring large model weights to run on the web server itself. This keeps the deployment practical while preserving the ability to experiment with different open-weight model configurations.

Why Does Open Innovation Matter?

For ProofPocket, open innovation is about more than avoiding dependence on a single model API.

1. The reasoning can be inspected and changed.

Document requirements vary significantly. A scholarship application, internship application, and academic program may use different terminology for similar documents. An open-weight model makes it possible to experiment with prompts, model versions, and fine-tuning strategies to improve how the system interprets these requirements.

2. The model is not locked into one provider.

By separating the AI provider from the application logic, developers can evaluate different compatible inference setups without rewriting the entire product. This makes it easier to compare quality, latency, and cost.

3. Local inference becomes a possible deployment option.

A compatible local inference setup can allow document analysis to run on a user's own machine, reducing the need to send sensitive document text to an external inference provider. This requires suitable hardware and configuration, but it offers a meaningful privacy advantage for users who need it.

4. The workflow can improve through reproducible evaluation.

Developers can create synthetic test documents, define expected requirements and evidence matches, and evaluate where a model makes mistakes. They can investigate false positives, adjust the pipeline, and share improvements with the community.

That last point matters particularly for paperwork automation. A system that confidently makes an incorrect match can be worse than one that admits uncertainty.

Open innovation gives developers more freedom to investigate those failure modes rather than treating the model as an unquestionable black box.

One important distinction: hosting ProofPocket on Render does not automatically make document processing private or offline. The privacy characteristics depend on where the inference runs, what information is transmitted, and how the application handles uploaded files.

My Agent Session

The Lazy Payoff

The real payoff is reducing the number of repetitive decisions a person has to make.

Without ProofPocket, someone might repeatedly switch between an application instruction PDF, their downloads folder, scanned certificates, and a checklist to determine whether everything is ready.

With ProofPocket, the intended workflow is simpler:

Upload → Analyze → Review exceptions → Download.

The system brings the relevant evidence and missing items together, reducing unnecessary searching and repeated checking.

I want the most meaningful measure of success to be the time spent reaching a correct, reviewable application pack—not the number of AI calls or the number of documents processed.

The evaluation should compare manual completion time against assisted completion time using the same document set, while also measuring incorrect matches and missed requirements. That way, any time savings can be assessed alongside the accuracy of the result.

Prize Categories

Render — Best Use of Render: Hosting the deployed application and backend.
Gemma — Best Use of Gemma: Using an open-weight model for requirement interpretation and evidence matching.
MongoDB — Best Use of MongoDB Atlas: Managing project data and document-to-requirement relationships, with semantic retrieval where configured.
Sentry — Best Use of Sentry Agent Tracing: Observing processing stages, errors, and performance.

These categories reflect the intended integrations; the final submission should include only those that are actually implemented and demonstrable.

devchallenge #hf26challenge

I Built a Private AI Spreadsheet Repair Tool That Runs on Windows, No Cloud API Required

Slevin Cordeiro — Sun, 18 Oct 2026 16:54:05 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Small businesses deal with messy spreadsheets every day. Supplier lists, inventory records, and business data often contain duplicate entries, inconsistent categories, missing values, incorrectly formatted dates, and numbers stored as text.

Cleaning this data manually takes time, and uploading sensitive business information to an external AI service isn't always an option.

That's why I built Patchwork AI — an open-source, local-first Windows desktop application that helps users identify, understand, and repair messy spreadsheet data.

Instead of sending spreadsheet contents to a cloud AI API, Patchwork AI combines deterministic data profiling with locally running AI models. The application can analyze data-quality issues and suggest transformations while keeping the user in control of the changes.

What makes Patchwork AI different?

Local-first AI: Integrates with Ollama to run supported open-weight models locally.
Deterministic data profiling: Identifies common data-quality issues without requiring an AI model.
Spreadsheet support: Imports and exports CSV and Excel files.
AI-assisted suggestions: Helps with column mapping and category normalization.
Human-in-the-loop workflow: Users can review proposed changes before applying them.
Safer transformations: The original file is preserved rather than intentionally overwritten during export.
Reviewability: Includes change history and undo functionality to make data-cleaning decisions easier to inspect.

The goal is simple: make useful AI-powered data cleaning accessible to people who don't want to depend on cloud APIs or send their business data to external AI providers.

Demo

Watch the demo:

In this walkthrough, I demonstrate Patchwork AI using a deliberately messy supplier and inventory spreadsheet.

The dataset contains inconsistent category names, mixed date formats, extra whitespace, missing values, duplicate-like records, inconsistent currency formatting, and invalid email addresses.

The demo walks through importing the spreadsheet, identifying data-quality issues, reviewing proposed fixes, and exporting the resulting data.

The aim is to show how Patchwork AI can make a spreadsheet that needs manual attention easier to inspect and clean.

Code

GitHub repository: https://github.com/Shade555/patchwork-ai

Patchwork AI is open source and released under the Apache License 2.0.

The repository includes the application source code, setup instructions, a sample dataset, and tests.

Contributions, bug reports, and suggestions are welcome!

How I Built It

I built Patchwork AI as a native Windows desktop application using C#, .NET 8, and WPF.

The project is organized into separate components for the desktop interface, data profiling, AI integration, transformation planning, transformation execution, and file import/export.

The main technologies include:

C# and .NET 8: Core application logic and desktop application runtime.
WPF and WPF-UI: Native Windows interface.
CommunityToolkit.Mvvm: MVVM architecture and application state management.
ClosedXML: Excel workbook processing.
CsvHelper: CSV file processing.
Ollama: Local inference through a locally running model.
xUnit: Automated testing.

One of the important design decisions was to avoid making the AI responsible for every operation.

Data-quality issues such as missing values, whitespace, duplicates, and inconsistent formatting can often be detected deterministically. These checks do not require an LLM.

AI is used where it can add value, particularly when interpreting ambiguous column names or suggesting how inconsistent categories should be normalized. The application provides a workflow for reviewing proposed transformations before applying them.

This separation makes the system more predictable than an approach where an LLM directly rewrites an entire spreadsheet.

I also included a synthetic supplier-inventory dataset so that people can test the application without needing to provide their own business data.

Why Does Open Innovation Matter?

AI should not be limited to people and businesses that can afford cloud subscriptions or are comfortable sending their data to external services.

Open-source tools allow developers to inspect how an application works, modify it for their own needs, and contribute improvements. Open-weight models and local inference also create opportunities to build AI applications without sending every request to a third-party AI provider.

Patchwork AI brings these ideas into an everyday workflow: spreadsheet cleaning.

A small business should be able to explore AI-assisted data cleaning while maintaining greater control over its files. A developer should also be able to inspect the code and extend the tool rather than being locked into a proprietary service.

There is still work to do, especially around handling more complex spreadsheets, improving transformation suggestions, and expanding test coverage. Making the project open source means those improvements can happen collaboratively.

For me, open innovation means making practical technology more accessible, understandable, and adaptable.

My Agent Session

I used an AI coding assistant during development to help with implementation, debugging, and refining the application architecture.

The development process involved separating deterministic data checks from AI-generated suggestions, organizing the application into maintainable services, and testing the spreadsheet import and transformation workflow.

This helped me iterate on the project while keeping the code organized into smaller, more maintainable components.

My First User

My first test user was me.

I tested Patchwork AI using a synthetic supplier and inventory spreadsheet containing intentionally introduced data-quality problems. This allowed me to evaluate the import, profiling, transformation-review, and export workflow without exposing real business information.

The test dataset also makes it easier for other developers to reproduce the same scenarios and verify how the application behaves.

The next step is to get feedback from someone who regularly works with spreadsheets, especially someone managing inventory, suppliers, or small-business operations. Their feedback will help identify which data-cleaning features are genuinely useful and which parts of the workflow need improvement.

Prize Categories

Featured Categories

Best Use of Gemma — $200

Patchwork AI is designed to support local inference through Ollama, and Gemma can be used as the local model for AI-assisted spreadsheet analysis and transformation suggestions.

Thanks for organizing the Hacktoberfest Open-Source AI Challenge. Building Patchwork AI has been an opportunity to explore how local AI can solve a practical problem while keeping the user in control of their data.

Building Mundane: An Open-Source AI Field Investigator

Slevin Cordeiro — Sun, 11 Oct 2026 12:50:51 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 1: Touch Grass

What I Built

Most AI products are designed to capture your attention and keep you staring at a glowing rectangle. They give you instant, authoritative-sounding answers so you never have to leave your chair.

I wanted to build the opposite.

Mundane is an open-source AI field investigator that turns everyday outdoor observations into small, structured scientific inquiries. Instead of acting like an encyclopedia that dispenses prefabricated trivia, it acts like a curious field biologist walking alongside you. Its job is to help you notice physical reality, record empirical clues, evaluate competing hypotheses, and return with a deeper understanding of the world.

How It Works in Practice

Imagine you are walking down your street and notice something ordinary: small green rosettes of broadleaf plantain are flourishing along one narrow seam in the concrete sidewalk, but the parallel seam two feet away is completely bare.

When you enter this observation into Mundane (or snap a photo and note that it rained yesterday):

Investigation Formulation: The system generates a structured inquiry titled "Pavement Fracture Botany", articulating a central question, observable physical phenomena to look for, and a safe, practical field procedure.
"Continue Outdoors" Mode: The interface switches to a high-contrast, distraction-free view designed to remain legible under direct sunlight. Crucially, each step explicitly instructs you to put your phone in your pocket, step back, and inspect the physical environment.
Clue Collection & Grounded Breakdown: When you record what you see—such as fine grit packed into the vegetated crack, or tire scuff marks near the bare seam—the AI doesn't just guess what's happening. It separates your notes into five rigorous categories:
- Tangible, observable facts
- Reasonable deductions
- Competing alternative explanations
- Questions that remain unanswerable without microscopic or laboratory assays
- Safe next outdoor checks
Hypothesis Testing Matrix: You form a hypothesis (e.g., "The plant flourishes because foot traffic compaction keeps moisture from evaporating quickly"). The system compares your gathered field clues against this and alternative explanations (such as micro-topography runoff or seed dispersal shadows), grading them as Supported, Plausible but Unverified, Inconclusive, or Contradicted.
Field Journal Dossier: Once complete, the investigation is archived into a persistent naturalist journal with explicit uncertainty ratings, your personal reflections, and a one-click Markdown export.

Mundane never presents an AI guess as a scientifically established fact. If a question cannot be resolved with the naked eye, the application explicitly says so.

Demo

Repository: https://github.com/Shade555/Mundane
Live Deployment: https://mundane.onrender.com (Hosted on Render)

Running 100% Locally

If you want to run Mundane completely offline on your own machine without sending a single byte to an external server:

# 1. Pull the open-weight Gemma model via Ollama
ollama pull gemma2:2b

# 2. Clone the repository and install dependencies
git clone https://github.com/Shade555/Mundane.git
cd Mundane
npm install

# 3. Launch the local field desk
npm run dev

Open http://localhost:3000 and the app will detect your local Ollama instance automatically.

Code

The complete source code is open source under the Apache 2.0 license on GitHub:

👉 github.com/Shade555/Mundane

Core Separation of Observation and Hypothesis

One of the central design challenges was preventing the AI from hallucinating definitive conclusions when looking at ambiguous real-world phenomena. To enforce scientific discipline, every observation passes through a strict Zod schema before reaching the user:

// src/lib/ai/schemas/investigation.ts
export const ObservationAnalysisSchema = z.object({
  directlyObservableEvidence: z.array(z.string()).describe(
    "Tangible, physical facts verified with the naked eye (colors, textures, moisture, orientation)."
  ),
  reasonableDeductions: z.array(z.string()).describe(
    "Logical inferences derived directly from the observed evidence."
  ),
  alternativeExplanations: z.array(z.string()).describe(
    "Other plausible reasons for the observed phenomenon."
  ),
  cannotBeDeterminedWithoutLab: z.array(z.string()).describe(
    "Questions requiring soil chemical testing, microscopic analysis, or longitudinal observation."
  ),
  recommendedNextFieldCheck: z.string().describe(
    "A practical, safe outdoor action the user can do right now to gather more clarity."
  ),
});

Combined with a deterministic safety validator that intercepts any instructions encouraging tasting wild plants, handling unknown fungi, disturbing wildlife, or trespassing, this ensures the system remains both safe and intellectually honest.

How I Built It

Mundane is built around a clean, decoupled architecture where the user experience, AI inference, and persistence layers remain independent.

graph TD
    Client["Next.js 15 Client ('Continue Outdoors' Sunlight Mode)"]
    API["Server Route Handlers (/api/ai/*)"]
    Safety["Outdoor Safety & Zod Schema Filter"]
    Mastra["Mastra Agent Coordinator"]
    Provider["AI Provider Interface"]
    Ollama["Local Ollama (Gemma 2 2B)"]
    Remote["Remote Inference (Groq / OpenAI-compatible)"]
    Storage["Storage Adapter (Local Offline Store / Supabase RLS)"]

    Client --> API
    Client --> Storage
    API --> Safety
    Safety --> Mastra
    Mastra --> Provider
    Provider -->|Local Mode| Ollama
    Provider -->|Cloud Mode| Remote

The Tech Stack

Frontend & App Framework: Next.js 15 (App Router) with TypeScript and Tailwind CSS. The UI uses an earth-toned, editorial color palette (paper, forest, charcoal, botanical) designed specifically for readability outdoors.
Open-Weight AI Models: Google Gemma 2 (gemma2:2b for fast, low-latency reasoning on standard CPUs) and Gemma multimodal (gemma4:12b for photo analysis).
Inference Runtime: Ollama as the local runtime, connected via a configurable provider interface (src/lib/ai/providers/ollama-provider.ts). When deployed to the cloud, the provider automatically speaks standard OpenAI-compatible wire format (tested with Groq hosting open-weight models like Qwen and Llama 3.3).
Agent Orchestration: @mastra/core coordinates the investigation synthesis, evaluating multi-hypothesis matrices and calibrating uncertainty ratings.
Storage Layer: Dual-mode storage adapter. By default, it operates 100% offline using the browser's local storage and in-memory store. When cloud sync is desired, it synchronizes with Supabase PostgreSQL protected by Row Level Security (RLS) migrations.
Hosting: Configured for Render as a Web Service (render.yaml) with full multi-stage Docker support.

Engineering Challenges & Trade-offs

1. The CPU Latency Problem on Local Hardware

Initially, I tested running a larger 12B model (gemma4:12b) for all text operations locally on my laptop. Because inference was executing on consumer CPU threads without a dedicated workstation GPU, each generation took between 90 and 180 seconds. Sitting on a park bench waiting three minutes for a response completely broke the user experience.

Switching text reasoning to gemma2:2b dropped response times to ~12–18 seconds while maintaining strict JSON grammar adherence. This taught me an important lesson: in an outdoor context where the user should be looking at trees rather than waiting for a spinner, a well-prompted small model beats an unwieldy large model every time.

2. Cross-Platform Module Resolution on Linux Containers

During deployment to Render, the Next.js production build succeeded locally on Windows but failed on Render's Linux environment with Module not found: Can't resolve '@/lib/db'. Because Windows is case-insensitive, subtle bundler alias quirks in Next.js client components were masked locally. Resolving this required configuring explicit Webpack path mappings in next.config.ts and establishing deterministic relative imports for runtime instances.

Why Does Open Innovation Matter?

Open-source and open-weight AI is not just a philosophical preference for Mundane; it is the reason the application can exist in the form it does.

True Privacy for Field Observations: When someone uses an app to document their daily walks, they are recording where they spend time, what they notice near their home, and potentially uploading photos of their immediate surroundings. With closed, commercial APIs, that personal behavioral data is routinely routed through proprietary servers and retained for corporate training. With open-weight models running on Ollama, every observation, photo, and reflection stays on the user's physical machine.
Off-Grid, Signal-Free Autonomy: Nature reserves, coastal trails, and rural woods rarely have reliable 5G connections. Proprietary API-dependent apps simply stop working the moment you cross the tree line. An open-weight model executing locally doesn't need an internet connection, an active subscription, or an API credit balance.
Model Substitutability Without Vendor Lock-In: Because the inference layer targets an open runtime rather than proprietary SDKs, users and developers can swap models as hardware allows—running gemma2:2b on a modest laptop, a quantized Qwen model on an edge device, or a 70B parameter model on a local workstation.
Open Weights vs. Open Source: It is important to be clear about licensing terms. Google's Gemma models are distributed as open weights under the Gemma Terms of Use (permitting commercial and research applications), while the Mundane application code is licensed under the OSI-approved Apache 2.0 license. Open innovation allows these two ecosystems to complement each other effectively.

My Agent Session

This project was built with an agentic pair-programming workflow in Google Antigravity. Automated test runs (all 27 tests passing across safety checks, JSON extraction, schemas, storage adapters, and end-to-end inference workflows) and iterative debugging logs were maintained throughout development.

To view or import the corresponding DevRelay agent transcript:

Developers using the DevRelay CLI can inspect and submit development logs using devrelay sessions submit.
If you have an active DevRelay account, sessions can be viewed directly in your DevRelay profile.

Prize Categories

Best Use of Render: Mundane is deployed as a production Web Service on Render (render.yaml), hosting the Next.js App Router frontend and server route coordinator with zero manual infrastructure configuration.

DigiPico: I Built a Gamified AI Companion with Mastra & Gemma 4 to Help My Friend Fall in Love with Tech

Slevin Cordeiro — Sun, 04 Oct 2026 18:05:00 +0000

This is a submission for the Hacktoberfest Weekend Challenge: Build for a Friend

What I Built

I built DigiPico, a gamified, mobile-first AI learning companion designed specifically for a close friend of mine who doesn't particularly like tech.

As a developer, I’ve always wanted to share my passion for software with her, but she has always found the tech world deeply intimidating, dry, and unapproachable. Traditional learning platforms felt too much like reading a textbook, and code editors felt cold and unforgiving. I wanted her to be genuinely interested in how things work behind the scenes, so I realized I needed to disguise the learning process as a welcoming, interactive game.

That’s where DigiPico comes in. Pico is a supportive, adorable blue penguin tutor that completely removes the intimidation factor from learning computer science. Instead of lecturing, Pico breaks down complex concepts into bite-sized, interactive learning paths. The app adapts to her specific interests, generates dynamic multiple-choice quizzes to test her knowledge, and even creates safe, browser-based JavaScript sandboxes where she can write and execute real code. Every time she completes a challenge or runs code without errors, she earns XP and unlocks achievements.

The Hand-off:
When I finally handed the app over to her to test on her phone, her reaction was incredible. She immediately gravitated towards the cute penguin, spent almost an hour playing through the JavaScript coding challenges, and told me: "This is the first time programming actually felt like a fun puzzle game instead of an overwhelming math test." That alone made the whole weekend worth it.

Demo

📱 Best Experience: DigiPico was designed from the ground up with a mobile-first UI. For the absolute best experience, open the link on your smartphone to see it behave exactly like a native app!

🚀 Live App: https://digipico.onrender.com/

(Tip: Create a new account, type in a topic like "Artificial Intelligence" or "Robotics", and interact with Pico across the Chat, Learn, and Build tabs!)

Code

Shade555 / DigiPico

🐣 DigiPico is a cute AI-powered tech companion that helps beginners discover, understand, and learn technology through personalized explanations, hands-on challenges, learning paths, and opportunities. Powered by Gemma 4 and an open AI stack, DigiPico turns tech curiosity into confidence and building.

# 🐧 DigiPico

A gamified, mobile-first AI learning companion designed to cure tech intimidation.

🏗️ Architecture

flowchart TD
    User(["📱 User / Capacitor Mobile"]) --> |HTTPS| Render
    
    subgraph Render [Render Monolith]
        UI[Frontend UI]
        API[Backend API Routes]
        UI <--> API
    end
    
    subgraph Brain [Mastra AI Orchestration]
        Mastra[Mastra Framework]
        Tools[Agent Tools]
        Mastra --- Tools
    end
    
    API <-->|Prompt/Response| Mastra
    
    Tools -->|Live Web Search| SerpApi["🌐 SerpApi"]
    Tools -->|Chat Memory| Backboard["🧠 Backboard"]
    
    Mastra <-->|Open-Weights LLM| Gemma["🤖 Gemma 4"]
    
    API <-->|Text-to-Speech| ElevenLabs["🗣️ ElevenLabs"]
    API <-->|Auth & Gamification| Mongo[("🍃 MongoDB Atlas")]
    API <-->|Tech Readiness Prediction| TabPFN["📊 TabPFN"]
    
    Render -->|Error & Agent Tracing| Sentry["👁️ Sentry"]

📖 Overview

DigiPico was built for the Hacktoberfest Weekend Challenge: Build for a Friend.

The goal? To help a non-technical friend fall in love with technology. Traditional tutorials feel like reading a dry textbook, and code editors are cold and unforgiving. DigiPico solves this by disguising tech education as a welcoming, interactive…

View on GitHub

How I Built It

DigiPico is a Next.js monolithic full-stack application built around a powerful, open-source AI agent system. Here is exactly how every piece of the stack came together:

Capacitor: Because my friend is most comfortable on her phone, I designed the app for mobile screens first. The codebase is fully integrated with Capacitor, allowing this exact web codebase to be seamlessly bundled as a native iOS and Android application.
Mastra Framework & Gemma 4: I used the open-source Mastra agent framework as the central orchestration layer. Mastra connects directly to a Google Gemma 4 (26B) open-weights model. Gemma 4 was explicitly prompted to maintain Pico's warm, non-judgmental persona. Mastra allows Gemma 4 to seamlessly call custom background tools to generate strictly formatted JSON learning curriculums, dynamic quizzes, and customized JavaScript coding sandboxes on the fly.
Backboard: For an AI companion to feel like a real friend, it needs context. I used Backboard to effortlessly persist the agent's memory and chat threads. This ensures Pico always remembers my friend's previous questions and progress.
MongoDB Atlas: Serves as the robust primary database handling user authentication and gamification states like tracking her XP, daily streaks, and unlocked achievements. It also powers the app's seamless user experience by caching asynchronously generated AI curriculums and coding challenges in the background, ensuring near-instant load times when she navigates the app.
SerpApi: Integrated as a custom Mastra tool, allowing Pico to actively search the live web for the latest beginner-friendly tech news and active hackathons to share with her in the chat.
TabPFN: I integrated TabPFN to run tabular machine learning predictions on her progress. It analyzes her accumulated XP, login streak, and quiz scores to predict a "Tech Readiness Score" subtly adjusting the difficulty of her curriculum.
ElevenLabs: Text on a screen can still feel a bit clinical. I integrated ElevenLabs' Text-to-Speech API to give Pico an adorable, expressive voice in the chat interface.
Sentry: Nothing frustrates a beginner more than unexplained bugs. Sentry is implemented for full-stack error tracking and agent tracing to catch any UI crashes or AI generation errors.
Render: The entire monolithic Next.js application is deployed seamlessly as a single Web Service on Render, configured entirely via a declarative render.yaml blueprint.
GitHub Copilot: I heavily utilized GitHub Copilot as my AI pair programming partner. Copilot dramatically accelerated my development speed over the weekend by scaffolding the complex Tailwind UI components and predicting boilerplate API route structures for the monolithic backend.

Why Does Open Innovation Matter?

Open innovation was the absolute core of why this project worked. Using an open-weights model like Gemma 4 gave me complete control over how the agent behaved. Closed APIs often have strict, unpredictable safety guardrails that aggressively block attempts to generate raw, executable code snippets, or they forcefully inject corporate, formal tones into the chat. By using an open model like Gemma, I had the freedom to completely override its standard behavior to act exclusively as a playful, empathetic penguin without interference.

Additionally, building on the open-source Mastra agent framework let me seamlessly orchestrate different tools on my own terms. Instead of being locked into a single walled ecosystem, I had the absolute freedom to wire up SerpApi for live tech news and Backboard for memory exactly how I wanted. Open-source gave me the power to change how the agent behaves at a foundational level something a rigid, closed ecosystem would never allow.

Prize Categories

I am proudly entering the following partner categories:

Best Use of Render
Best Use of TabPFN
Best Use of Gemma
Best Use of Backboard
Best Use of ElevenLabs
Best Use of Mastra
Best Use of MongoDB Atlas
Best Use of Sentry Agent Tracing
Best Use of SerpApi
Best Use of GitHub Copilot

First Post For Hacktoberfest

Slevin Cordeiro — Thu, 01 Oct 2026 17:54:28 +0000

its a test post, also for connecting DEV account to Hacktoberfest profile