DEV Community: Web Dev | Adit

A Quick Look at OpenAI’s New Visual Agent Toolkit 🚀

Web Dev | Adit — Wed, 08 Oct 2025 02:14:58 +0000

Hey everyone!

I just spent some time diving into OpenAI’s new AgentKit announcement, and honestly—I had to share this. If you’re building with AI (or thinking about it), this might change your workflow.

What’s AgentKit, in One Line

AgentKit is a unified toolkit from OpenAI for building, deploying, and optimizing AI agents—no more stitching together half-tools and custom pipelines.

What I Found Most Interesting

1. Agent Builder (Visual Workflow Magic)

A drag-and-drop canvas where you can compose multi-agent logic, connect tools, and set guardrails.
You get preview runs, versioning, inline evals, and templates to speed things up.
According to OpenAI, Ramp went from “blank canvas → buyer agent” in a few hours. They claim 70% faster iteration.
LY Corporation built a work assistant in under two hours.

Beta status: Agent Builder is currently in beta.

2. ChatKit (Embeddable Chat UIs, Without the Pain)

Makes it trivial to embed chat-based agents into websites or apps. Handles streaming, threads, UI, etc.
Canva says they saved over two weeks using ChatKit and integrated it in less than an hour.
Use cases: support bots, onboarding, internal knowledge assistants, and more.

Availability: ChatKit is generally available now.

3. Evals (Better Testing, Smarter Iteration)

AgentKit expands the Evals suite with:

Datasets — build evals more easily over time (with graders, human annotations)
Trace grading — evaluate full agent workflows end to end
Automated prompt optimization — generate improved prompts from evaluation feedback
Third-party model support — test models from other providers in the same system

Reported impact:

“The evaluation platform cut development time … by over 50%, and increased agent accuracy 30%.” — Carlyle

Availability: These new Evals capabilities are generally available now.

4. Other Notes: RFT, Connectors, Pricing

Reinforcement Fine-Tuning (RFT) is rolling out new features: custom tool calls & custom graders.
Connector Registry helps manage data tools (Dropbox, Google Drive, etc.) across workspaces.
Guardrails let you enforce safety rules (mask PII, detect jailbreaks).
Pricing & availability:
- ChatKit + new Evals: generally available.
- Agent Builder & Connector Registry: rolling out in beta to certain users/orgs.
- All these tools are included under standard API pricing (no extra “AgentKit tax” … for now).

My Take

AgentKit feels like a friction remover. The visual builder alone helps non-engineers (product, legal) understand and collaborate. Versioning + integrated evals reduce risk of breaking things in later iterations. If you’ve been dragging your feet on building agents, this might be the push you needed.

If you're already experimenting with agent architectures—or even considering them—AgentKit is worth your attention.

Call to Action

If you have access, play with Agent Builder’s beta
Try embedding a chatbot via ChatKit
Build an evaluation pipeline using the expanded Evals features
Share your experiments, gotchas, or wins—I'd love to hear

Source: OpenAI — Introducing AgentKit

✨ Building a Simple AI Prompt Keeper (with Bootstrap 5 + Alpine.js)

Web Dev | Adit — Sun, 03 Aug 2025 06:18:30 +0000

🧭 Introduction

Hey there 👋

As someone who often leans more on the introverted and quiet side of things, I usually keep a lot of ideas and helpful tools to myself. But lately, I've been trying to get more comfortable sharing, even if it's something small. This blog post is my humble attempt to share a simple project that I built — something practical, lightweight, and beginner-friendly.

The idea came from my day-to-day habit of saving useful prompts I use with AI tools like ChatGPT. Whether it's for writing, fixing code, or helping with daily office tasks, prompts can save time — and brain juice 😅

So, I built a little tool to save and organize these prompts. It’s not fancy, but it works — and I hope it inspires someone out there to try building their own version.

⚒️ What I Used

Bootstrap 5 — For fast and clean UI layout
Alpine.js — A minimal JS framework to handle UI interaction
localStorage — To save prompts locally without a backend
Express (optional) — Added a basic server for easier deployment later

This stack was intentionally simple. No React, no databases, no build tools. Just HTML, a bit of JavaScript, and some love.

📌 Features (So Far)

Add, edit, delete prompts
Save to localStorage (keeps data even after refresh)
Filter/search prompts

Planned next:

Add tags/categories
Export/import prompts

💡 Sample Prompt Use Cases

Here are a few examples of how I personally use this:

Blog outline generator
Translate casual Indonesian into formal English
Polite reminder email template
Summarize messy meeting notes

It helps a lot when you have "your own prompt assistant" saved and ready.

🤔 Why Build This?

Mostly because I needed it myself. But also because I’ve been reminding myself: you don’t need to build the next big thing to make something worth sharing.

This little project helped me:

Practice Alpine.js
Think about UI and UX
Write a bit of cleaner HTML/CSS

Also, I believe small tools are underrated. There’s something fun in crafting something that just works — without all the overhead.

📦 Source Code

👉 github.com/gitbyaditya/prompt-keeper-ai

🙏 Final Thoughts

If you're a junior developer, or just trying to get more confident with coding — I hope this shows that it's okay to start small.

If you’ve built something similar or have feedback to improve this, I’d genuinely love to hear your thoughts — feel free to drop a comment.

Thanks for reading 🙌

🧪 Trying the Replit + Notion Integration — My Early Thoughts

Web Dev | Adit — Fri, 09 May 2025 03:04:52 +0000

Hey devs,

I’ve been testing the new Replit x Notion integration, and it’s like a solid combo for quickly spinning up content-driven apps. Notion acts as the CMS, Replit handles the front-end, and AI helps bridge the two by generating the scaffolding from prompts.

Here’s what stood out:

🔑 Key Features

Pull or Push Notion Data
You can pull data (like blog posts, job listings) from a Notion DB, or push new data back in—like form submissions or simple UGC.
AI-Powered Code Generation
Replit’s Agent lets you define app structure with a prompt. I fed it a short brief and got a basic blog layout up and running.
Notion as a Lightweight CMS
Everything lives in Notion—title, description, body. You can enhance content with AI, add formulas (e.g., reading time), or control visibility with checkboxes.
Real-Time Front-End Sync
The app fetches data live from Notion, essentially giving you a custom headless CMS workflow.
Stackable Integrations
You can layer in OpenAI, Gemini, authentication, or workflows (e.g., moderation, enhancement, email hooks) depending on the use case.
Quick Prototyping
This setup is solid for MVPs or internal tools—less boilerplate, faster iteration.

🧠 My Take

It’s promising, but there’s still room for improvement.

Some things—like managing the Notion connection or customizing advanced logic—feel a bit rough around the edges. But the core idea is strong, and it’s already useful for lean builds or experiments.

👀 Curious what you think:

Would you actually use Notion as your backend for client or production work?
Does AI-generated boilerplate help—or get in the way?

Let me know. Always down to swap thoughts with other devs.
Until next post—keep building.

Try Replit | Try Notion

AutoGate — AI Permission Control for CMS | Permit.io Authorization Challenge

Web Dev | Adit — Sun, 04 May 2025 16:26:37 +0000

This is a submission for the Permit.io Authorization Challenge: Permissions Redefined

What I Built

AutoGate is a futuristic access control system that allows users to type natural language requests like:

"A user wants to post in fun/creative/journal category"
"Who can post in news category?"

and instantly receive a permission decision.

The system parses the sentence, predicts the category using AI (Gemini/OpenAI) model, checks the user's attributes, and evaluates the permission dynamically.

This project redefines how permissions can be applied — moving away from rigid hardcoded logic toward dynamic, AI-assisted authorization that feels natural and intuitive.

Demo

🔗 Live Demo Link

📷 Screenshots:

Project Repo

(Here)

My Journey

During the development of AutoGate, I focused on creating a natural and fluid experience for dynamically checking user permissions through AI understanding and smart attribute-based policies.

One key design choice was to use a structure for permission rules, enabling rapid iteration and flexibility during the prototyping phase. The AI model plays a core role by interpreting the user's intent and context, allowing AutoGate to handle complex permission logic without burdening users with technical language.

Challenges I faced:

Designing a consistent parsing logic to reliably extract user attributes, actions, and objects from free-text input.
Creating a scalable way to manage permissions dynamically while keeping the system responsive and user-friendly.
Balancing fast prototyping needs with a vision for future enterprise-grade architecture.

What I learned:

Building flexible, AI-driven authorization is possible — but maintaining safety, governance, and explainability is critical for real-world adoption.
Planning for "day two problems" (like auditability, rollback, and policy versioning) is essential even when focusing on MVP.

Future Work: While the current version of AutoGate uses lightweight AI parsing, the plan is to expand it to include:

Full version control and audit logs for permission changes.
Multi-admin approval flows for sensitive policy updates.
Transitioning to distributed databases for scalable permission management.
Real-time consistency handling and safe cache invalidation during permission updates synced with Permit.io.

These expansions will allow AutoGate to evolve from a dynamic prototype into a robust, production-ready authorization platform.

Using Permit.io for Authorization

For the prototype phase, permission decisions are handled by referencing a map function that simulates dynamic policy logic.

In future iterations, the plan is to integrate directly with Permit.io's platform through their APIs to:

Replace static permission checking with Policy-as-Code.
Manage real-time policy updates and versioning with Permit CLI.
Enable advanced workflows such as approval chains and contextual access control.

This phased approach allowed me to prioritize user experience and core AI integration first, while ensuring a clear path toward full Permit.io integration as the system matures.

🧠 OpenAI Just Leveled Up (Again): What I Think Devs Should Know from the o3 & o4 Update

Web Dev | Adit — Thu, 17 Apr 2025 02:45:19 +0000

This update dropped just hours ago — here’s what stood out to me as a solo dev keeping an eye on this stuff.

OpenAI recently pushed a mini update about what’s brewing with GPT-4 (and beyond), and while it wasn’t a full-on keynote event, there’s a lot worth unpacking. As someone who builds and experiments with AI in real projects, here’s my quick and opinionated breakdown — minus the corporate hype.

⚡ GPT-4 Turbo is the New Default

So, if you’re using GPT-4 inside ChatGPT right now, you’re actually using GPT-4 Turbo — not the original GPT-4. It’s faster, cheaper, and supports a bigger memory window.

Why I think it matters:

⚡ Faster and cheaper — no complaints here.
🧠 128k token context — helpful for devs working with big docs, transcripts, or codebases.
💡 Makes me wonder how far they are from something like GPT-5, or if Turbo is their next-gen already under a different name.

🧠 ChatGPT Has Memory Now

This one’s pretty wild. Memory is gradually rolling out to more users, and yes — it remembers stuff between chats.

What it remembers:

Your name
How you like your answers (short vs long, casual vs formal, etc.)
Info you’ve shared before (like preferences or work context)

You can view/edit/delete memory anytime from the settings.

Why I’m paying attention:

This could change how we use GPT for dev tasks — imagine a bot that actually remembers your stack, workflow, or coding style over time. Still early, but the potential’s huge.

🧰 Custom GPTs (Without Code)

You can now spin up your own version of ChatGPT with specific instructions, uploaded files, and even tools like browsing or API calling.

You can set things like:

What it should sound like
What files or docs it can access
Whether it can use external tools (like APIs or search)

There’s also a GPT Store where people share their creations — kinda like a plugin marketplace.

Why I’m into it:

This gives indie devs (like me) a way to build mini AI tools without writing a backend. It's still a bit clunky in parts, but it's moving fast.

🎙️ Voice Mode Is Getting Seriously Impressive

The new voice experience isn’t just about text-to-speech — they’re aiming for real-time, back-and-forth convos that feel more like talking to a person.

Less lag, smoother flow
Better voice quality
Early demo shows it feels natural

Why I care:

If they pull this off, it opens up some fun ideas for building voice-first tools or interfaces — not just assistants.

🔧 OpenAI Is Becoming… a Platform?

They’re clearly not just shipping models anymore. They’re building their own infra, working on their own chips (reportedly), and bundling tools (text, vision, voice, code) into one accessible API.

My 2 cents:

It feels like they’re aiming to become the go-to layer for AI-powered products. Whether that's a good or risky thing depends on your perspective — but either way, it’s smart to keep tabs if you're building anything AI-adjacent.

🧭 TL;DR: What This Update Signals (To Me)

GPT is getting smarter, faster, and more personalized
You can now build custom AI tools without touching code
And ChatGPT is quietly becoming more like a persistent assistant

None of this is a mic-drop on its own, but the direction feels clear: we're moving toward AI tools that actually know you and work with you, not just respond to prompts.

If that’s the road we’re heading down — I’m all in for experimenting early.

If you're playing with the new memory feature, or making your own GPTs, I’d love to hear what you're building — drop a note or link below 👇