DEV Community: Md Adil Iftekhar

Celebration Event Planner

Md Adil Iftekhar — Fri, 30 Oct 2026 18:45:57 +0000

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

What I Built

I built Celebration Event Planner AI, an intelligent event-planning assistant that helps people organize birthdays, anniversaries, weddings, graduation parties, and other special celebrations without the stress of managing everything manually.

Instead of spending hours calculating budgets, managing guest lists, creating schedules, and deciding decorations or activities, users can simply enter their event details and receive a personalized celebration plan.

The assistant uses context-aware decision-making and intelligent planning logic to generate budget breakdowns, recommend themes and activities, organize event timelines, manage guest information, and create actionable checklists. It also adapts when users change their budget, guest count, venue preferences, or other requirements.

Who gets to be a little lazier? Anyone planning a celebration! From busy students and families to first-time event organizers, everyone can save time, reduce planning stress, avoid unnecessary expenses, and focus more on enjoying the special moments.

The goal: Make event planning smarter, simpler, more affordable, and accessible to everyone.

Plan Smarter. Celebrate Better. 🎉

Demo

celebration-event-planner-1.onrender.com

Code

MDADILIFTEKHAR / Celebration-event-planner

Celebration Event Planner AI 🎈

An intelligent, context-aware celebration orchestrator and budget assistant built for the AI Code Submission Challenge.
Transforms event ideas into actionable, budget-conscious, chronologically validated plans that dynamically adapt to real-time changes without losing host preferences.

1. Project Summary

Celebration Event Planner AI is a production-quality full-stack application that solves the complexity of celebration and party planning. Rather than a static checklist or generic chatbot, it implements a dual-mode intelligent architecture:

Deterministic Local Planning Engine: Provides instant, mathematically sound budget allocations, chronological scheduling, and context-tailored recommendations without requiring any API keys or paid external services.
Optional LLM Integration: Secure server-side enhancement via Google Gemini or OpenAI with graceful fallback to local intelligence if keys are unavailable or network requests fail.

2. Problem Statement

Planning celebrations (birthdays, weddings, anniversaries, graduations, baby showers, dinner parties) involves interdependent variables:

Limited and volatile budgets.
Shifting guest counts and…

View on GitHub

How I Built It

<I built Celebration Event Planner AI using a full-stack architecture with React 19, TypeScript, Vite, Python, and FastAPI.

The core intelligence is powered by a custom deterministic planning engine that combines rule-based reasoning, constraint validation, budget optimization, and context-aware recommendation logic. Rather than depending entirely on an external LLM, the application can independently understand structured event requirements and generate practical plans without requiring a paid AI API.

I implemented a dual-mode AI architecture:

Local Intelligence Engine:** Handles event planning, budget allocation, mandatory expense protection, guest calculations, timeline generation, and personalized recommendations using deterministic algorithms.
Optional LLM Integration: Provides an extension point for Google Gemini and OpenAI through secure server-side API integration for enhanced natural-language understanding and creative suggestions.
Intelligent Fallback: If an AI provider is unavailable, the application automatically falls back to its local planning engine, keeping the essential functionality available.

The backend uses FastAPI and Pydantic for API development and data validation, while SQLite provides lightweight persistence. The frontend uses React, TypeScript, Tailwind CSS, and Recharts for an interactive planning dashboard and budget visualizations.

The most important engineering feature is the dynamic change-adaptation engine. When users modify their budget, guest count, dietary requirements, or venue preferences, the system recalculates affected parts of the plan while preserving mandatory expenses and unrelated user decisions.

I also implemented automated testing using Pytest and Vitest to validate planning logic, budget calculations, API behavior, and frontend functionality.

AI approach: Deterministic local intelligence + optional LLM integration + context-aware decision-making + graceful fallback.

Why Does Open Innovation Matter?

Open innovation matters because AI-powered event planning should be accessible, affordable, transparent, and adaptable to everyone.

By building Celebration Event Planner AI around a custom local decision-making engine and an extensible AI architecture, I made the core planning experience independent of expensive, closed AI APIs.

This approach makes it possible to perform budget calculations, generate event timelines, manage guest requirements, and provide personalized recommendations without requiring a paid AI subscription or continuous external API access.

It also gives developers the flexibility to integrate different AI providers, experiment with open-weight models, customize planning logic, and improve the system without being locked into a single vendor.

Most importantly, open innovation makes the project easier to extend, inspect, reproduce, and improve collaboratively. My goal is to make intelligent celebration planning more accessible while keeping users in control of their budgets and decisions.

Open innovation means building technology that others can understand, adapt, and improve—not just use.

Prize Categories

Render – Best Deployed Application

Celebration Event Planner AI is deployed using Render, providing a hosted full-stack application with a Python FastAPI backend and a React-based frontend. The deployment demonstrates practical cloud hosting, API integration, and an accessible event-planning experience.

RepoMedic AI: An AI Agent That Fixes Bugs—and Proves the Fix Works

Md Adil Iftekhar — Wed, 14 Oct 2026 13:06:37 +0000

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

## What I Built: RepoMedic AI

I built RepoMedic AI, an AI-powered bug repair agent that helps developers find bugs, generate code fixes, and verify whether those fixes actually work.

Traditional AI coding assistants can suggest solutions, but generated code is not always correct and may introduce new bugs. RepoMedic AI addresses this problem with an evidence-gated repair workflow: it analyzes a bug, proposes a patch, checks the changes against safety rules, runs eligible tests in an isolated environment, and presents the results so developers can inspect the evidence before trusting a fix.

The project is designed for software developers, computer science students, open-source contributors, freelancers, and engineering teams that want to spend less time debugging and more time building reliable software.

Who would pay for it? Freelance developers and software agencies could pay to reduce debugging time, while startups and engineering teams could use it to speed up code reviews and routine bug fixing. Open-source maintainers could benefit from faster issue investigation, and educational institutions could use it as a practical tool for teaching debugging and software testing.

The goal is simple: make AI-assisted debugging more transparent, secure, and dependable. Rather than accepting an AI's claim that a bug is fixed, developers get a proposed patch and test evidence they can evaluate themselves.

Explore RepoMedic AI:

Live demo: https://repomedic-ai-stqt.onrender.com/
GitHub repository: https://github.com/MDADILIFTEKHAR/RepoMedic-AI

RepoMedic AI is currently a working project and public demo, with opportunities to expand into paid developer tools and team-focused plans as the product matures.

Demo

repomedic-ai-stqt.onrender.com

Code

MDADILIFTEKHAR / RepoMedic-AI

RepoMedic AI 🩺

RepoMedic AI is an open-weight AI-powered Python bug-repair harness built around an Evidence-Gated Repair Loop.

Unlike conversational coding assistants that rely on model self-attestation ("I fixed the bug!"), RepoMedic AI enforces strict, deterministic verification: a proposed unified-diff patch is never considered successful until it passes deterministic policy gating and executes cleanly in an isolated test environment with zero regressions.

🎯 Problem Statement

Modern coding models frequently hallucinate that a patch works, propose sprawling changes that touch unrelated files, tamper with test assertions to make failing suites artificially pass, or generate insecure code. Furthermore, executing arbitrary untrusted code directly on developer machines poses significant security risks.

RepoMedic AI solves this by introducing:

Deterministic Security & Policy Gating: Unified diffs are inspected before application. Path traversal (../), changes to protected files (requirements.txt, .git/, CI workflows), and test alteration tampering are unconditionally blocked.
…

View on GitHub

## How I Built It

I built RepoMedic AI around an open-weight coding model, Qwen2.5-Coder, with a custom Python-based agent harness designed to do more than generate code. My goal was to build an agent that can propose a bug fix, evaluate the proposed changes, run tests, learn from failure evidence, and report whether the repair actually passes verification.

1. Open-Weight AI and Local Inference

The core model is Qwen2.5-Coder:7B, an open-weight model specialized in code generation, code reasoning, and code repair. I integrated it with Ollama, which allows developers to run the model locally without depending on a hosted inference API.

For hosted inference, RepoMedic AI also supports configurable OpenAI-compatible endpoints, including providers such as OpenRouter, Together, and self-hosted vLLM deployments. This gives developers flexibility to choose between local inference and hosted model access.

2. Building the Agent Around Evidence

Instead of relying on a prompt that simply asks an AI to fix a bug, I built a custom, evidence-gated repair loop in Python.

The workflow begins by scanning the target repository and running baseline tests to identify existing failures. The agent sends the relevant context and failure evidence to the coding model, which proposes a repair as a unified diff.

Before applying the patch, a deterministic policy gate checks whether the changes comply with the project's safety rules. It rejects prohibited modifications, including test tampering, path traversal, and changes to protected files.

Accepted changes are evaluated in a disposable Git worktree or temporary workspace, keeping experiments separate from the original repository. Tests can run in restricted Docker containers with networking disabled and resource limits. If a test fails, RepoMedic AI extracts the actual failure output and feeds it back into the model for another repair attempt.

I limited the repair process to three attempts to keep the workflow bounded and predictable. A patch is considered verified only when it passes the required policy checks and test execution.

3. Developer Experience and Evaluation

I built a web-based developer interface with live repair progress, syntax-highlighted diffs, test evidence, and benchmark results. I also added a command-line interface and REST API so the repair workflow can be used programmatically.

To evaluate the approach, I created a deterministic benchmark containing 10 Python repair tasks. In the recorded results, one-shot repair achieved a 20% pass rate, while the bounded repair loop achieved a 50% pass rate. This is a 30-percentage-point improvement on that small benchmark, not a guarantee of real-world repair accuracy.

The project also includes an Agent Skill file following the Agent Skill Open Standard, helping make the repair capability discoverable by compatible agent environments.

4. Deployment and Open Innovation

I deployed the web application on Render and published the source code on GitHub. In hosted demo mode, users can explore the predefined benchmark fixtures without enabling unrestricted execution of arbitrary repositories on the public server.

Open-weight AI matters to this project because developers can run Qwen2.5-Coder locally, experiment with their inference setup, and maintain more control over their code and model environment. The interchangeable provider configuration also makes it possible to adapt the system to different infrastructure needs.

My main design principle is simple: the model proposes the fix, but deterministic checks and test results decide whether it works.

Project links

Live demo: https://repomedic-ai-stqt.onrender.com/

GitHub repository: https://github.com/MDADILIFTEKHAR/RepoMedic-AI

Why Does Open Innovation Matter?

My Agent Session

My First User

For your RepoMedic AI submission, remove the “Prize Categories” section. The AWS Builder Center Weekend Challenge requires the #agents tag and the specified article content; it does not list separate partner prize categories.

AWS Builder Center

Note: Render is your project's deployment platform, not a prize category.
Make sure #agents is added as the article tag.

SafePlate

Md Adil Iftekhar — Fri, 09 Oct 2026 10:09:56 +0000

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

What I Built

I built SafePlate, an AI-powered meal planning and food-safety companion for a friend who struggles with choosing meals because of food allergies. It helps users plan affordable meals based on their allergies, dietary preferences, budget, cooking time, and available ingredients.

SafePlate includes an AI meal planner, a “Can I Eat This?” ingredient checker, pantry-based recipe generation, and smart ingredient substitutions. Its key feature is a safety-first system that checks AI-generated meals against declared allergens instead of blindly trusting AI recommendations.

I designed it around open-weight AI running locally through Ollama, so users can keep their personal food preferences and allergy profiles on their own device, switch models, and reduce dependence on closed cloud AI services.

My goal is to make everyday meal planning easier, more personal, and more accessible for someone I care about. SafePlate combines open-source innovation with practical problem-solving to build technology that makes a real difference in someone's daily life.

Demo

Video Project 1.mp4 - Google Drive

drive.google.com

Code

MDADILIFTEKHAR / SafePlate

🛡️ SafePlate — AI Meal Planning Built Around What YOU Can Safely Eat

Local-first · Privacy-respecting · Allergy-safe · Budget-conscious

Features · Screenshots · Architecture · Quick Start · Testing · Contributing

🧠 What is SafePlate?

SafePlate is a local-first, privacy-respecting, allergy-safe meal planning application and instant food safety checker. It is built for anyone managing:

🥜 Serious food allergies (peanuts, tree nuts, sesame, etc.)
🥗 Strict dietary preferences (vegetarian, vegan, non-vegetarian)
💰 Daily financial constraints (e.g., ₹150/day budget)
⏱️ Busy schedules (under 30-minute cooking time)

Unlike generic chatbots or thin AI wrappers, SafePlate enforces a strict non-negotiable architectural invariant:

🔒 AI GENERATES. RULE ENGINE VALIDATES. APPLICATION DECIDES.

The AI is never trusted as the final authority on food safety. A deterministic, multi-layered rule engine validates every single suggestion before it reaches you.

✨ Key Features

1. 🔬 Deterministic Food Safety Knowledge Engine

Classifies every food item into…

View on GitHub

How I Built It

I built SafePlate using open-weight AI with Ollama for local inference, along with React, Vite, Tailwind CSS, Python, FastAPI, and SQLite. The AI layer is designed to be configurable, allowing different models to be swapped without rewriting the application's core logic.

The main workflow uses an agent loop: it generates a meal, checks the ingredients, validates allergy restrictions, verifies the budget and cooking time, and attempts to repair the meal if any constraints are violated. A deterministic safety engine performs the final validation, so the AI cannot simply override an allergy conflict.

I also designed a demo mode so the application can demonstrate its core features without requiring a locally running model. The goal is to make open-source AI a functional part of the product, enabling local processing, greater control over personal data, model flexibility, and the potential for offline use.

This approach combines generative AI with rule-based validation to make meal planning more personalized, transparent, and privacy-conscious.

Why Does Open Innovation Matter?

Open innovation matters for SafePlate because food allergies are personal, and users should have more control over where their sensitive information is processed. By building around open-weight AI and local inference with Ollama, SafePlate can generate personalized meal ideas on a user's own device without depending on a closed cloud AI API for its core intelligence.

An open approach also gives me the freedom to switch models, experiment with different prompts, customize the agent loop, and improve the system without being locked into one provider or its pricing. Most importantly, I can combine AI-generated recipes with an independent, rule-based allergy safety engine that checks ingredients before a meal is recommended.

A closed API could provide meal suggestions, but the open approach gives me greater control over the architecture, privacy, and future development. It also creates the potential for offline use once the model and required data are available locally. For me, open innovation means building a tool that I can understand, adapt, and improve for someone I care about.

My Agent Session

Prize Categories

Open Source AI — Uses open-weight AI models through Ollama for local inference and customizable meal generation.
AI Agents — Implements an agent loop that generates meals, validates constraints, and attempts to repair unsafe or over-budget suggestions.
Social Impact / Build for a Friend — Solves a real everyday problem by helping someone with food allergies plan personalized meals.
Privacy & Local AI — Prioritizes local processing of personal allergy profiles and reduces dependence on external AI APIs.