This is the output of running the test function we forgot to include that in the video

🧠 FuncForge: AI-Powered Interactive Function Testing Playground

✨ Overview

FuncForge is a dynamic AI-driven tool designed to let developers instantly test individual functions from their code without building an entire frontend, writing test scripts, or navigating boilerplate setup.

Using AI to deeply understand your code and the inputs it requires, FuncForge empowers developers with real-time, visual, and interactive function testing—bridging the gap between writing and validating logic.

💡 Inspiration

As developers, we often find ourselves writing complex backend functions—only to realize we have no immediate way to test them without:

Building a full frontend
Writing cumbersome Postman requests
Manually setting up mock data and test cases

This delay slows down iteration, blocks creative momentum, and forces engineers into unnecessary busywork.

We asked:
What if we could just click on any function, and instantly get a smart interface to test it?

🚀 What It Does

FuncForge is a frontend IDE + AI assistant that:

Lets you paste your backend code in a Monaco editor.
Analyzes the code on submit and detects all functions using Python's AST module.
Displays a dropdown of function names.
When you click “Try” on a function:
- The function is sent to an LLM (Groq LLaMA 3).
- The LLM intelligently rewrites the function to accept parameters instead of input(), and returns results instead of printing them.
- The LLM also identifies and returns a schema of inputs required (e.g., 2 strings + 1 image).
We dynamically generate input fields (text boxes, file uploaders, number sliders, etc.) based on that schema.
You fill them, hit Test, and we execute your exact function using your inputs—all instantly displayed back.

⚡ No frontend wiring. No test scripts. Just you and your logic—running live.

🧠 How We Use AI

We leverage Groq’s LLaMA 3 (70B) model to:

Parse arbitrary Python code into modular, testable function blocks.
Identify external dependencies (e.g., input(), other functions) and replace them with injectable parameters.
Build a structured, JSON-based input schema that our frontend can use to build the UI on the fly.

This makes the entire experience feel like:

“Write code. Click. Interact.”

Our AI is not just a copilot—it's a collaborator in the testing pipeline.

🧪 Tech Stack

Tech	Purpose
React + Tailwind	Frontend UI + theming
Monaco Editor	In-browser IDE for live code editing
Flask	Backend code parser + executor
Python AST	Code introspection and function extraction
Groq LLaMA 3	Natural language code rewriting + input inference
Framer Motion	Smooth animated UI transitions

🧩 Challenges We Faced

Safely parsing and executing user code
We had to sandbox execution and isolate the function logic to prevent unsafe operations.
Making AI output reliably parseable
LLMs tend to output Markdown-wrapped JSON. We built a robust system to strip formatting and sanitize the response.
Dynamically building UIs
Creating a flexible system that updates based on LLM-defined inputs was tricky but essential for reusability.
Debugging multi-part file uploads
Managing image inputs and previews alongside standard text fields required careful handling in both backend and frontend.

🧠 What We Learned

How to structure prompts that yield consistently formatted and functional AI output.
The power of combining traditional code parsing (ast) with AI enhancement for a hybrid approach.
Designing for human-AI collaboration—our system doesn’t just automate; it enhances and adapts to the user’s thinking.

Why are we different?

✅ Innovation

We replaced the conventional test suite + frontend build loop with a fully dynamic, AI-interactive function testing environment. There’s nothing like it—especially for solo backend developers.

✅ Use of AI

AI isn’t a gimmick here—it reads your function, infers the UX, and lets you run it live. It's doing real interpretation and transformation that would otherwise take multiple manual steps.

✅ Originality

FuncForge introduces a zero-frontend testing model. Instead of mocking inputs or building GUIs, we let AI build your testbed on the fly. Think of it like “Postman for Python functions”—but smarter and visual.

✅ Design

We put a lot of effort into clean UI, dark/light theming, smooth transitions, image previews, and responsive layouts—making sure it’s both functional and beautiful.