🚀 I Built an AI Code Conversion Benchmark Platform

Aryan Kumar — Fri, 03 Apr 2026 07:19:53 +0000

Over the last few weeks I’ve been working on a project called CodexConvert.

It started as a simple idea:

What if we could convert entire codebases using multiple AI models — and automatically benchmark which one performs best?

So I built a tool that does exactly that.

🔁 Multi-Model Code Conversion

CodexConvert lets you run the same conversion task across multiple AI models at once.

For example:

Python → Rust
JavaScript → Go
Java → TypeScript

You can compare outputs side-by-side and immediately see how different models perform.

📊 Automatic Benchmarking

Each model output is evaluated automatically using three metrics:

✔ Syntax Validity
✔ Structural Fidelity
✔ Token Efficiency

Scores are normalized to a 0–10 scale, making it easy to compare models.

🏆 Built-in Leaderboard

CodexConvert keeps a local benchmark dataset and generates rankings like:

Rank Model Avg Score
🥇 GPT-4o 9.1
🥈 DeepSeek 8.8
🥉 Mistral 8.4

You can also see which models perform best for specific language migrations.

🧠 Modern Workspace UI

The interface works like a developer dashboard:
Inputs | Model Outputs | Benchmark Insights
You can upload an entire codebase, run conversions, and analyze results in one place.

🔒 Privacy-First Architecture

One important design decision:
CodexConvert has no backend server.

Everything happens in your browser:
• API keys stay in session storage
• code is sent directly to the AI provider
• nothing is stored remotely

🧩 Tech Stack
React + TypeScript
Vite
Tailwind CSS
JSZip
OpenAI-compatible API providers

💡 Why I Built This
Developers constantly ask questions like:

Which AI model is best for Python → Rust?
Which model produces cleaner TypeScript?
Which one is most token-efficient?

CodexConvert helps answer those questions.

🔗 GitHub

If you’d like to try it out or contribute:

👉 https://github.com/aryanjsx/Openclaude

Feedback is very welcome.

I’m especially interested in ideas for:

• better benchmarking metrics
• additional model providers
• new leaderboard visualizations

Thanks for reading 🙌

I Built an AI That Turns Notion Tasks Into Real Projects (AURA MCP)

Aryan Kumar — Mon, 30 Mar 2026 18:11:09 +0000

Modern development workflows are fragmented.

We plan in tools like Notion, but we execute somewhere else — terminals, IDEs, CLI tools, and project generators. This constant context switching slows us down and turns us into the bridge between our own ideas and the tools that implement them.

I wanted to experiment with a simple question:

What if Notion didn’t just store tasks… but actually executed them?

That idea led to AURA MCP.

🚀 Introducing AURA MCP

AURA MCP (Autonomous Unified Resource Architect) is an execution engine that turns a Notion database into an automation layer.

Instead of writing a task and manually implementing it, AURA can:

Read tasks directly from Notion
Interpret the task using AI
Validate the execution plan
Scaffold a real project with working code
Update Notion with the results

So the workflow becomes:

Write task in Notion
↓
AI interprets intent
↓
Project created on disk
↓
Notion updated with results

In other words:

One sentence in → real project out.

🧩 The Problem

If you’re a developer, this workflow will feel familiar:

Write a project idea in Notion
Open a terminal
Create a project structure
Add boilerplate files
Come back to Notion and mark it done

Planning and execution live in completely different worlds.

Even modern tools don’t solve this:

Tool Limitation
Zapier / Make Automation without intelligence
AI Chatbots Generate text, not real files
Copilot Helps while coding, not before
Notion Integrations Sync data, but don’t execute tasks

Notion captures intent beautifully.

But it cannot act on it.

💡 The Idea

AURA MCP bridges the gap between intent and execution.

Instead of copying ideas into tools, AURA reads your tasks and turns them into real actions.

Example:

Task in Notion
Build a task manager with React
What AURA Does
Fetches the task from Notion
Interprets it using AI
Generates a structured plan
Creates a React project on disk
Writes the output back to Notion
Result
output/task_manager/
├── package.json
├── src/App.js
├── src/index.js
├── src/App.css
├── public/index.html
└── README.md

And the Notion task automatically updates:

Status: Done
Output: Project scaffolded successfully
Framework: React
Files: 6 generated
🧠 AI + Deterministic Execution

AURA uses a hybrid architecture.

1️⃣ AI Interpreter

Natural language tasks are converted into structured plans using a single LLM call.

Example output:

{
"action": "scaffold_project",
"framework": "react",
"project_name": "task_manager"
}
2️⃣ Validation Layer

Every AI output is validated before execution.

Checks include:

Allowed frameworks
Sanitized project names
No path traversal
Valid schema
3️⃣ Rule-Based Fallback

If the LLM fails or an API key isn’t available:

AURA switches to a keyword-based interpreter.

This means the system never breaks.

🔌 Built with MCP (Model Context Protocol)

AURA MCP is exposed through the Model Context Protocol, allowing AI systems to interact with it as a tool.

It provides three MCP tools:

🚀 run_aura

Runs the entire pipeline.

Notion → Interpret → Execute → Update Notion
📋 get_pending_tasks

Fetches all pending tasks from Notion.

⚙️ run_single_task

Runs the pipeline directly from text input without using Notion.

This means AI clients like Claude Desktop can invoke AURA directly.

🏗️ Architecture

The project follows a modular architecture:

Notion API
↓
Interpreter (AI or rules)
↓
Validator
↓
Executor
↓
Notion Writer

Each part lives in its own service layer:

notion.service.js
interpreter.service.js
validator.service.js
executor.service.js
orchestrator.js

The MCP server simply exposes this pipeline as tools.

🧰 Tech Stack

AURA MCP is built with:

Node.js
JavaScript (CommonJS)
Model Context Protocol SDK
Notion API
OpenAI API
Zod validation
dotenv configuration

Projects generated by AURA include:

React
Node.js / Express
FastAPI
🛡️ Safety & Reliability

Several design decisions ensure the system is stable:

Only one LLM call per task
Strict plan validation
Automatic fallback interpreter
Sanitized filesystem operations
Graceful error handling

Even if the AI produces invalid output, the system still works.

🎯 Why This Is Interesting

Most AI tools talk.

AURA acts.

Instead of producing suggestions or code snippets, it executes real operations on your machine.

This demonstrates a different direction for AI tools:

AI as an execution layer, not just a conversation interface.

📂 GitHub

If you want to check out the project:

GitHub:
https://github.com/aryanjsx/aura-mcp

If you find it interesting, consider ⭐ starring the repo or contributing.

🔮 Future Ideas

Things I’m exploring next:

GitHub repo creation
Deployment automation
Multi-step project pipelines
More frameworks and templates
Final Thought

We spend a lot of time moving ideas between tools.

Projects like this explore a different idea:

What if the tools simply executed the intent directly?

Notion might remain a workspace for ideas.

But with systems like AURA MCP, it could also become a workspace for execution.

If you have feedback or ideas, I’d love to hear them!

Forem: Aryan Kumar

🚀 I Built an AI Code Conversion Benchmark Platform

I Built an AI That Turns Notion Tasks Into Real Projects (AURA MCP)