DEV Community: Rohan Sharma

AI Native DevCon’26: The London conference for developers building with AI

Rohan Sharma — Thu, 21 May 2026 06:06:32 +0000

The bottleneck moved from writing code to governing it.

The promise was 2× throughput. The reality is 2× the review queue, 2× the security exposure, and a CI signal you can no longer trust. AI Native DevCon 2026 is for the engineering leaders who have to figure out how to ship anyway.

AI Native DevCon 2026 lands at The Brewery in London on June 1 and 2, with a hybrid track for remote. This is the conference for VPs of engineering, CTOs, platform owners, security leads, and senior engineers running agents in production, or about to. 500+ builders. Four tracks.

Guy Podjarny, founder of Tessl, organizer of AI Native DevCon, and previously of Snyk, frames the 2026 question:

“If 2025 was the year coding agents started showing real promise, 2026 is the year we figure out how they hold up in production. The challenge is no longer getting an agent to work, it is getting it to work consistently across teams, codebases, and environments without constant human correction.”

The schedule is organized around four tracks: context engineering (building with agents), agent orchestration (verification when CI is no longer enough), organizational enablement (coordination at agent throughput), and agent enablement (security and governance). Each maps to a problem most teams are already hitting.

The agenda is built around the problems they actually have right now.

1. “We do not know how to build with agents yet.”

How the engineer’s role is changing, and what products designed for humans need to do once agents start using them. By 2026, that question lands on every platform team. This is the context engineering track.

Ryan Lopopolo (OpenAI), Harness Engineering. Concrete patterns for systems where humans set direction and agents execute, including the review and approval surfaces that keep it safe at scale.
Dana Lawson (Netlify, CTO), Built for Humans. Now Agents Are Here. What changes in a developer platform when half the users are non-human, and the API and UX decisions Netlify made in response.
Ian Thomas (Meta), AI Native Engineering. How a large engineering org is restructuring workflows around agent-assisted development.
Steve Ruiz (tldraw), Agents on the canvas. Interaction patterns for visual agents, with shipping examples you can copy.

2. “We can generate code. We cannot verify it.”

CI is no longer evidence of correctness. Two years of agent-generated code has proved it. The agent orchestration track is about what to put in its place.

Justin Cormack (ex-Docker CTO), When Tests Lie. Runtime signals that flag agent-introduced drift before it reaches users.
Dave Farley (Founder & CEO of Continuous Delivery Ltd. - 250k on Youtube), Vibe Coding, really? The ideas that may actually survive the AI programming revolution, beyond hype, demos, and generated boilerplate.
Chad Fowler, Regenerative Software. An architectural model where components are regenerated rather than patched, and what verification looks like when code is short-lived by design.

3. “AI writes code faster than teams can coordinate.”

Two years into coding-agent adoption, throughput is up roughly 2×. Coordination cost scaled with it. The organizational enablement track covers review, ownership, and team structure.

Guy Podjarny (Tessl), Skills are the new Code (keynote). The case for treating skills as proper software: versioned, tested, owned, reviewed. With the Tessl Registry now holding 2,000+ evaluated skills, the talk covers what that means for repo structure and review process.
Birgitta Böckeler (Thoughtworks), State of Play: AI Coding Assistants (keynote). Two years of field data on which adoption patterns work and which create future technical debt.
Patrick Debois, The Rise of Agent Enablement. Agent Enablement is the function that owns reliable agent adoption inside an engineering org. It defines standards for skills, evals, and workflows, and sits next to DevOps and Platform Engineering. Patrick’s session covers who owns it, what they do, and how teams formalize it.

4. “Your AI is a new attack surface.”

Vulnerability classes that did not exist 18 months ago, and the controls most teams have not put in place yet. This is the agent enablement track from a security and governance angle.

Liran Tal (Snyk), Your AI Agent Installed Malware Because a SKILL.md Told It To. Live demo of prompt-injection via SKILL.md manifests, with the threat model and mitigations.
Joseph Katsioloudes (GitHub), Code Security Reinvented. How SAST, secret scanning, and review need to change for AI-generated code.
Jack Wotherspoon (Google), Humans vs. Slop. New rules for open source maintainers when an unknown share of contributors are agents.

Why engineering leaders should attend

Five things your team brings back to Monday:

A verification model that does not assume CI catches the regression
Threat models for prompt-injection and SKILL.md attacks, with mitigations
Team structures and review workflows that scale with agent throughput
A working definition of Agent Enablement as a discipline, including ownership and scope
A model for evaluating skills before they go org-wide, with review patterns and KPIs

Hosts and the wider lineup

Hosted by Sam Hepburn and Patrick Debois. Day-one keynote from Lieven Scheire on AI from outside the engineering bubble. The wider roster covers agent observability, MCP transports, runtime intelligence, brownfield adoption, and team-level adoption metrics, with practitioners from Anthropic, OpenAI, NVIDIA, Adobe, Hugging Face, Mozilla.ai, Cisco, Nearform, GitHub, and much more.

Full speaker list and abstracts: tessl.io/devcon.

TL;DR

Dates: June 1 and 2, 2026
Format: 2 days in-person or 1 day virtual
Venue: The Brewery, Barbican, London.
Register: https://luma.com/aidevcon-ldn26?coupon=R30 (R30 auto-applies at checkout to knocks off 30% off)
Bringing a team? Contact at tessl.io/get-in-touch, and we can arrange a group purchase discount.

See you at the event!

GPT-5.5 is OpenAI's best model. But paying more for it makes no sense.

Rohan Sharma — Wed, 06 May 2026 13:13:28 +0000

We added OpenAI’s gpt-5.5 model to our eval suite the day it launched. We ran 1,742 tests overall, which included over 45 task scenarios across using 11 real engineering skills, each run 6 times and averaged the data, which is shown in this blog.

TL;DR

The gpt-5.5 model has the highest raw capability of any OpenAI model we've tested. When it uses agent skills and performs the same tasks, it pretty much ties with gpt-5.4 on score but costs 63% more per run.

Question	Answer
Best Codex model out of the box?	gpt-5.5: 75.6 avg baseline, highest in the family
Best Codex model with skills loaded?	gpt-5.4 and gpt-5.5 tie at 89.3 and 89.4
Worth the 63% price premium over gpt-5.4?	With this data, we don’t think so
Any scenario where it wins?	Latency: 89.5s vs 135.4s for gpt-5.4
Should you use gpt-5.3 instead?	No, oddly enough, gpt-5.3 costs 47% more than gpt-5.4 for a worse result because of the token bloat.

The one-line verdict: gpt-5.5 is the most capable Codex model we've benchmarked, and when using agent skills to guide with tasks, it performs pretty much identically to a model that costs a third less. The interesting story is actually gpt-5.3, which costs more than gpt-5.4 and scores worse, because of the token bloat in 5.3. The per-token cost is, of course, more expensive with gpt-5.5.

The Key Takeaways

The most counterintuitive thing in this data: gpt-5.5 and gpt-5.4 score within 0.1 points of each other when given domain skills, 89.4 vs 89.3. The self-sufficiency story holds directionally, but these two models are functionally the same on skill-augmented work. The question is purely cost.

Join us at AI Native DevCon (use C0DE30 for 30% discount)

The gpt-5.3 story is sharper. The headline numbers put it at 83.9 with skills against 89.3 for gpt-5.4, a 5.4 point gap. It also costs $0.44 per run against $0.30 for gpt-5.4. You pay more and get less, which is a complete description of a bad deal.

You pay $0.49/run for 89.4 points with gpt-5.5. You pay $0.30/run for 89.3 points with gpt-5.4. The only dimension where gpt-5.5 leads is latency, at 89.5s against 135.4s. If you're running latency-constrained agents and can absorb the cost, it's a defensible choice. Otherwise you're paying a 63% premium for 0.1 points.

How It Stacks Up

Model	Task Scores (using agent skill)	Cost/run	Score/$	Avg lift
claude-opus-4-7	93.4	$1.00	93	+12.6
cursor:composer-2	89.6	$0.23	389	+15.4
gpt-5.5	89.4	$0.49	182	+13.8
gpt-5.4	89.3	$0.30	298	+15.2
gpt-5.3-codex	83.9	$0.44	191	+18.4
gpt-5-codex	78.7	$1.05	75	+10.0

gpt-5.5 and gpt-5.4 are functionally interchangeable on skill performance. The question is whether 45 seconds per run is worth $0.19.

What We Tested

This benchmark runs on Tessl, an agentic evaluation platform. A skill is a SKILL.md file, which is a structured markdown document containing rules, patterns, and examples for a specific domain. For the baseline run, the agent sees only the task prompt with no additional context. For the with-skill run, the SKILL.md is loaded into the agent's context alongside the task, same model, same task, same rubric. The score delta is the lift. The platform runs each scenario twice and scores the output against a pre-written rubric checklist automatically.

Each scenario was run 6 times and scored independently; all figures are averaged across those runs.

Why rubric checklists? Because the scenarios have objectively right answers. "Does the agent delete .eslintrc.json and create eslint.config.js?" is not a matter of opinion. Neither is "Does it use PKCE method S256?" or "Does it call pipeline() instead of chaining .pipe()?" Binary criteria eliminate evaluation noise wherever possible.

Example rubric: Modernize the Linting Setup for a Node.js Library, 11 criteria, 101 points.

Criterion	Points	Pass condition
neostandard installed	10	neostandard present in devDependencies
standard uninstalled	10	standard absent from devDependencies
Flat config file	10	eslint.config.js or .mjs exists, not .eslintrc*
neostandard in config	10	Config imports from neostandard and calls neostandard()
lint script uses eslint	10	package.json lint script runs eslint ., not neostandard . or standard .
migrate command used	10	Instructions reference npx neostandard --migrate to generate the config
lint:fix script present	8	lint:fix script runs eslint . --fix
CI uses non-fix run	8	CI config runs lint without --fix
standard config removed	8	No top-level standard key in package.json
lint-staged uses eslint	8	Pre-commit hook runs eslint --fix, not neostandard or standard
eslint@9 installed	8	eslint at version 9.x in devDependencies

A model that migrates the config correctly but leaves standard in devDependencies scores 91/101. One that creates eslint.config.js alongside .eslintrc.json instead of replacing it scores 0 on three criteria at once.

All skills and rubrics are published at simon/skills on the Tessl registry. Full eval results for this run can be found here.

The Data

Baseline scores (no skill), sorted by highest average

Model	docs	fastify	init	lint	node	node-core	oauth	octocat	skill-opt	snip	ts	Avg
claude-opus-4-7	85.7	80.9	79.7	92.9	73.7	91.6	75.7	84.7	85.0	60.1	78.8	80.8
gpt-5.5	89.9	71.8	63.6	94.4	64.6	72.3	73.6	85.5	83.2	54.7	78.3	75.6
gpt-5.4	87.6	66.7	71.1	84.5	62.3	77.4	77.5	80.5	80.8	50.9	75.9	74.1
cursor:composer-2	84.3	74.7	61.6	94.1	65.4	78.8	73.1	78.5	82.3	58.5	65.5	74.3
gpt-5-codex	80.2	67.3	60.2	84.9	60.4	76.5	72.9	75.3	63.8	47.5	66.5	68.7
gpt-5.3-codex	63.5	65.4	52.1	76.5	62.4	75.3	77.9	68.3	70.5	42.1	66.4	65.5

With-skill scores, sorted by highest average

Model	docs	fastify	init	lint	node	node-core	oauth	octocat	skill-opt	snip	ts	Avg
claude-opus-4-7	96.7	98.9	82.3	97.2	95.1	84.7	94.3	97.7	99.7	92.9	88.0	93.4
cursor:composer-2	95.6	93.9	85.7	96.4	94.0	92.3	83.9	94.5	93.7	85.3	70.4	89.6
gpt-5.5	96.1	86.0	81.8	96.3	88.3	88.6	91.7	92.1	96.0	86.5	79.2	89.4
gpt-5.4	97.1	76.9	80.0	98.1	84.8	93.7	91.6	95.7	94.6	90.9	79.0	89.3
gpt-5.3-codex	96.9	86.1	80.4	90.2	75.9	77.1	93.1	92.3	77.3	79.4	74.1	83.9
gpt-5-codex	62.9	88.9	74.8	92.1	66.3	77.7	89.3	85.9	80.7	86.0	61.1	78.7

Lift: what skills actually added per model, sorted by highest average lift

Model	docs	fastify	init	lint	node	node-core	oauth	octocat	skill-opt	snip	ts	Avg lift
gpt-5.3-codex	+33.4	+20.7	+28.3	+13.7	+13.5	+1.8	+15.2	+24.0	+6.8	+37.3	+7.7	+18.4
cursor:composer-2	+11.3	+19.2	+24.1	+2.3	+28.6	+13.5	+10.8	+16.0	+11.4	+26.8	+4.9	+15.4
gpt-5.4	+9.5	+10.2	+8.9	+13.6	+22.5	+16.3	+14.1	+15.2	+13.8	+40.0	+3.1	+15.2
gpt-5.5	+6.2	+14.2	+18.2	+1.9	+23.7	+16.3	+18.1	+6.6	+12.8	+31.8	+0.9	+13.8
claude-opus-4-7	+11.0	+18.0	+2.6	+4.3	+21.4	-6.9	+18.6	+13.0	+14.7	+32.8	+9.2	+12.6
gpt-5-codex	-17.3	+21.6	+14.6	+7.2	+5.9	+1.2	+16.4	+10.6	+16.9	+38.5	-5.4	+10.0

Reading the lift table. A few observations:

claude-opus-4-7 node-core: -6.9. Opus starts at 91.6 baseline on Node.js internals, the highest raw score on any skill for any model in the benchmark. Adding a skill that prescribes specific patterns for primordials and commit message format on top of a model that already knows the material produced interference, not uplift. The skill was written to close a gap that Opus doesn't have.
gpt-5-codex docs: -17.3. The same skill that boosted gpt-5.3-codex by +33.4 points degraded gpt-5-codex by 17. The Diátaxis framework is highly prescriptive about structure: tutorial titles must start with verbs, reference sections must contain no instruction. gpt-5-codex starts at 80.2 baseline for docs, it produces fluent, correct-seeming prose, and the skill's structural constraints appear to actively conflict with its default output style. High baseline does not predict positive lift.
gpt-5-codex ts: -5.4. Same pattern. A 66.5 baseline on TypeScript drops to 61.1 with the skill. The TypeScript skill enforces branded types and zero any, rules that require restructuring code rather than extending it. For a model with established TypeScript habits, the prescriptive guidance appears to create noise rather than correct the specific gaps.
claude-opus-4-7 init: +2.6. The lowest positive lift in the table. Claude Opus is the model that introduced the AGENTS.md convention, it was already near-ceiling on this skill before any context was added.
gpt-5.4 snip: +40.0. The single highest lift cell in the entire dataset. snipgrapher's private CLI documentation gives a model that knows nothing a complete specification for a tool it's never encountered. gpt-5.4's strong instruction-following amplifies that advantage cleanly.

The cost of running gpt-5.5 vs the alternatives

Model	Cost/run (with skill)	Time (with skill)	Score	Score/$
cursor:composer-2	$0.23	152.0s	89.6	389
gpt-5.4	$0.30	135.4s	89.3	298
gpt-5.3-codex	$0.44	87.9s	83.9	191
gpt-5.5	$0.49	89.5s	89.4	182
claude-opus-4-7	$1.00	158.9s	93.4	93
gpt-5-codex	$1.05	136.2s	78.7	75

More details about the 11 skills and scenarios

fastify-best-practices: Fastify has strong opinions, and the skill encodes them. Scenarios: Security Hardening for a Healthcare Web API (CORS scoped to two named origins, CSP + HSTS headers, HTTPS redirect, a wildcard * or a missing header scores zero); Authentication Service for a SaaS Platform (passwords migrated from bcrypt to argon2id, in-memory rate limiting replaced with Redis for multi-instance correctness, SIGTERM handled with close-with-grace); Protecting a Product Catalogue API from Overload (does it reach for @fastify/under-pressure or invent its own backpressure loop?); Order Management API with PostgreSQL (uses @fastify/postgres with correct pool lifecycle, not raw pg); Consistent Error Handling for a Multi-Tenant SaaS API (typed createError, uniform JSON shape, no stack traces to clients).

node-best-practices: The patterns in this skill diverge from what you'd find on Stack Overflow. Scenarios: Hardening Logging in a Fintech API (pino must redact auth tokens and raw card fields before they reach the SIEM, masking after the fact doesn't count); Webhook Receiver Service (structured logging of sensitive payment provider fields, graceful shutdown under concurrent in-flight requests); Fix Throughput Degradation in a High-Load API Gateway (dns.lookup() saturating the libuv thread pool, the fix is dns.resolve4() and UV_THREADPOOL_SIZE, not a caching layer); High-Throughput Merchant DNS Routing Service (concurrent resolution under load, observable thread pool saturation).

snipgrapher: A custom internal CLI with a non-public API. The model has never seen its documentation. At baseline, every model is essentially guessing (avg 50-60/100). With the skill, agents either follow the spec or they don't. Scenarios: Automating Changelog Snippet Images in CI (correct flag order, env var overrides, pipeline integration) and Code Snippet Image Pipeline for Documentation Site (batch rendering, profile configuration). This skill delivers the highest lift of any in the benchmark across every model, averaging between 27 and 40 points. The reason: it encodes knowledge that does not exist on the internet. Public skills are becoming less necessary as frontier models grow stronger. Private tooling is where skills still dominate.

typescript-magician: Not "add types to this function." Scenarios: Domain-Safe Payment Processing Types (branded types for AccountId, PaymentId, RefundId, plain type aliases don't count, as casts score zero); Product Catalog API for an E-Commerce Platform (TypeBox schemas inferred as TypeScript types end-to-end, internal cost fields stripped from public responses, no any); Eliminate any from a Data Pipeline Utility Library (tsc output captured before and after, zero any remaining, no @ts-ignore); Project Bootstrap: Node.js TypeScript Service (native --strip-types, no ts-node, no build step, no tsc in the start script).

oauth: Is the implicit flow explicitly removed? Is PKCE method S256? Is the refresh token replaced on rotation? Scenarios: Add User Authentication to a Fastify API (full Authorization Code + PKCE flow with @fastify/oauth2, state verification, token rotation); OAuth Login Integration for a Fastify Web App (CSRF-hardened flow, @fastify/session for state, correct cookie flags).

linting-neostandard-eslint9: ESLint v9's flat config is a breaking change. Scenarios checked whether agents actually migrated, not just created a new config alongside the old one. Is .eslintrc.json gone? Is standard removed from devDependencies? Scenarios: Modernize the Linting Setup (two variants: envparser open-source library and payments-api service); Add Linting to the Inventory Service (neostandard from scratch); Set Up Automated Lint Enforcement (husky + lint-staged pre-commit hook, CI step that blocks on violations).

documentation: Based on the Diátaxis framework. The skill teaches agents when to write a tutorial vs a how-to vs reference vs explanation. Scenarios: Restructure Documentation for a Configuration Library (sprawling confz README split into four Diátaxis types, tutorial title must start with a verb, reference section must contain no instruction); Getting Started Guide for a CLI Deployment Tool (shipctl onboarding tutorial with Goal→Prerequisites→Numbered steps→Verifiable result structure, no conceptual digressions in the steps).

init: Writing AGENTS.md / CLAUDE.md files that actually help AI assistants. Scenarios: Set Up Agent Instructions for a Growing Python Monorepo (3-year-old codebase, multiple service packages, identify the three constraints that cause the most agent damage); Set Up Agent Instructions for a Node.js Monorepo (workspace-aware package manager, per-package test commands, legacy directory exclusion); Audit and Slim Down a Bloated AGENTS.md (what to cut, what to keep, signal vs noise after a year of uncurated growth); Set Up Agent Instructions for a Growing Monorepo (hierarchical root-level vs per-package instructions, discoverability filtering).

octocat: GitHub CLI patterns and correct flag usage. Scenarios: Automate Feature Branch PR Submission (correct gh pr create flags, CI polling with gh run watch, merge only after checks pass); Preparing Commits for a Node.js Core Module Contribution (subsystem prefix, 72-char subject, Reviewed-By trailers, the format changelog toolbots parse); Prepare Node.js Core Contribution Commits (backport workflow, correct metadata for automated release pipelines); Automate Pull Request Workflow (reusable shell script, idempotent, surfaces CI failures before merge). nodejs-core: Contributing to Node.js core: primordials, commit message format, native addons with AsyncWorker. Scenarios: Product Catalog Caching Service (async-cache-dedupe, concurrency control to prevent thundering herd on a rate-limited upstream); Microservice Routing Layer: Latency Spike Investigation (diagnosing UV_THREADPOOL_SIZE exhaustion, dns.lookup() blocking the pool); Diagnose and Fix V8 Performance Regression in Analytics Processor (--prof, --trace-opt, reading isolate-*.log, acting on deoptimization reasons). skill-optimizer: Meta: given a poorly-written skill or benchmark report, improve it or interpret it correctly.

The Verdict

gpt-5.5 is a better model than gpt-5.4 on raw capability, and on latency it is not close. For everything else, they are the same model at different price points. Pay the 63% premium if you need the speed. Skip it if you care about cost or value per dollar.

The model to actually avoid is gpt-5.3. It costs 47% more than gpt-5.4 and scores 5.4 points worse. If you are running gpt-5.3 today, the case for switching to gpt-5.4 is strong on both cost and performance.

Frontier models are becoming more self-sufficient. The ROI on domain skills is concentrating in genuinely proprietary knowledge: your internal APIs, your custom tooling, patterns that simply aren't on the internet. Snipgrapher lifted every model by 27 to 40 points because no model had ever seen its documentation. ESLint v9 flat config lifted them by 2 to 14 points because capable models already know it.

The original author of this blog is Simon Maple and is originally posted on tessl.io/blog

Simon Maple is the Head of Developer Relations at Tessl, and AI Native Dev co-host. Previously, Simon was the Field CTO, and VP Developer Relations at Snyk, ZeroTurnaround, and IBM. He became a Java Champion in 2014, JavaOne Rockstar speaker in 2014 and 2017, Duke’s Choice award winner, Virtual JUG founder and organiser, and London Java Community co-leader.

My Docs Are Safer Than My Search History 😎

Rohan Sharma — Sun, 15 Feb 2026 10:20:01 +0000

This is a submission for the GitHub Copilot CLI Challenge: Build with AI

Hey there! Welcome back. This is my latest project that I'm super excited to share with you!

Remember that one time your friend asked you to "just quickly check" their Google Doc, and you spent 20 minutes figuring out if you had view-only or editing access? Or when your team's important document got accidentally shared with the entire internet? Yeah, me too. 😅

That's why I built Radhika's AI DocManager, a document management system that doesn't mess around when it comes to security, roles, and AI-powered features.

Live Demo: radhika-docmanager.vercel.app

What's This All About? 🤔

Imagine you and your partner have a shared notebook. But here's the twist:

You can write anything you want in your sections
Your partner can only read some sections (View Only)
Your partner can comment on other sections but not edit them (Comment)
Some pages are locked with a password because they contain surprise party plans 🎉

That's basically what this project does, but for teams and organizations!

Question for you: Have you ever accidentally deleted someone else's important document or had your document deleted by someone? How did that go? 😬

The Cool Features That'll Make You Go "Woah!" 🚀

1️⃣ Four Roles, Four Levels of Trust

Think of roles like relationship stages:

User (Dating Stage): You can only see and manage your own stuff. Can't touch anyone else's documents.
Admin (Committed Relationship): You can see everything in your organization and manage your team members. You're the responsible one now!
Super Admin (Marriage Level): Like Admin but with superpowers! You approve who joins your org, can promote people to Admin, and have elevated privileges. But you're still tied to your organization!
God (The Parent): Full control over the ENTIRE platform across ALL organizations. Can post documents to ALL organizations at once. The ONLY role with cross-org access! Ultimate power! 💪
- Important Note: God has read access to all documents across organizations for platform management, but the primary focus is on public documents and cross-org coordination. Organizations still maintain their privacy for internal operations.

Each role has a "weight" number. Higher weight = more authority. Just like how your mom outranks you when deciding what's for dinner! 😄

Important: Only God can see across organizations. Super Admin, Admin, and User are all scoped to their own organization!

2️⃣ Document Security That Actually Makes Sense

Your documents can have different classification levels:

Public: Everyone can see it (like your Instagram story)
Organization: Only your team can see it (like your company Slack)
Internal: More restricted (like your team's strategy docs)
Confidential: Top secret stuff (like your salary slip)
General: The default, casual classification

Plus, you can set access levels:

View Only: Read-only, no comments allowed (like when your partner says "just look, don't touch")
Comment: Can read and comment but not edit (like leaving sticky notes on a physical document)
Edit: Can make changes to the content
Full Access: Complete control (the relationship goals)

Want to add extra protection? Lock any document with a 9-digit password! 🔐

3️⃣ AI That Works For YOU (Not For Big Tech)

Here's the thing: I hate vendor lock-in. You know what's worse than a bad breakup? Being forced to stay with a service because you can't leave!

That's why Radhika's AI DocManager lets you bring your own API keys:

Groq (FREE tier available! Fast and perfect for getting started)
OpenAI (Premium quality)
Anthropic (Great for long documents)

Your keys are encrypted with AES-256-GCM encryption. That's military-grade security, folks! Even if someone breaks into the database, your keys are safer than your ex's secrets in your DMs. 🤫

The AI can:

Summarize documents (TL;DR generator)
Analyze sentiment (is this doc angry or happy?)
Extract key points (bullet points anyone?)
Improve writing (make it sound professional)
Translate content (hola, bonjour, namaste!)
Generate Q&A (instant study guide)
Custom prompts (ask it anything!)

Pro tip: You also get FREE local tools that work without any API key — Word Count, Structure Analysis, and Text Preview. All running in your browser!

4️⃣ Organizations That Don't Mix Like Oil and Water

Multiple organizations, complete data isolation. Think of it like this:

You have three friend groups:

College friends (Acme Corp)
Work friends (Globex Inc)
Gym friends (Initech LLC)

Each group has its own private WhatsApp group. Nobody from college friends can see what's happening in your work friends group. That's exactly how organizations work here!

To join an organization, you need an Organization Code (like a secret club password). A Super Admin must approve your membership request. No random people crashing your party! 🎊

How GitHub Copilot CLI Supercharged My Development 🚀

Okay, confession time: Building this project would have taken me MUCH longer without GitHub Copilot CLI. Let me tell you how it became my coding partner!

What is GitHub Copilot CLI?

Think of it as having a really smart friend who sits in your terminal and helps you with commands, debugging, and understanding code. You just talk to it in natural language!

How I Used It in This Project

1. Generating the Complete Supabase Schema

This was HUGE. Instead of manually writing hundreds of lines of SQL:

gh copilot suggest "generate supabase schema for document management system with organizations, users, documents, comments, and audit logs with proper foreign keys and indexes"

It gave me a complete schema structure! I just had to customize it for my needs. Saved hours of work!

2. Setting Up Row Level Security (RLS)

Supabase RLS policies are tricky. I asked:

gh copilot suggest "create row level security policy for organization isolation in supabase"

It generated the exact SQL I needed to ensure users can only see data from their organization!

3. Database Schema Debugging

When my foreign key constraints weren't working:

gh copilot explain "Why is my foreign key constraint failing between documents and profiles?"

Boom! Got the answer instantly and fixed the relationship properly.

4. Creating Storage Buckets with Policies

Setting up Supabase storage:

gh copilot suggest "create supabase storage bucket for documents with 50MB limit and access policies"

Got the complete SQL for buckets AND storage policies. No more digging through docs!

5. Complex Git Operations

Had to rebase multiple commits with conflicting changes:

gh copilot suggest "rebase last 5 commits and squash them into one"

Got the exact git commands I needed. No more Stack Overflow!

6. TypeScript Type Errors

When dealing with complex Supabase types:

gh copilot explain "Cannot find name 'UserRole' in this scope"

Instantly told me I needed to import from @/lib/supabase/types. No more hunting through files!

7. Debugging Permission Logic

When my role-based access control wasn't working:

gh copilot explain "why is my outranks function returning false for admin checking user role"

Helped me understand the weight comparison logic and fix the bug in minutes!

8. File Upload Implementation

Struggled with Supabase storage upload with progress:

gh copilot suggest "upload file to supabase storage bucket with progress tracking and error handling"

Got complete working code with progress bars and proper error handling!

9. Understanding bcrypt Hashing

When implementing password security:

gh copilot explain "difference between bcrypt compare and hash and when to use each"

Clear explanation that helped me implement secure authentication correctly!

10. Deployment to Vercel

Deploying with all environment variables:

gh copilot suggest "deploy next.js app to vercel with environment variables from .env file"

Got the proper CLI commands with all the flags needed!

11. Testing Database Queries

When testing complex SQL with multiple JOINs:

gh copilot explain "how to test row level security policies in Supabase without deploying"

It explained the whole local testing process step by step!

But do you know? I've even implemented most of the frontend with it as well. 😎

Why Copilot CLI is a Game Changer

No Context Switching: Stay in your terminal, no need to open browser
Natural Language: Ask questions like you'd ask a friend
Project-Aware: It understands your codebase context
Instant Answers: Faster than googling and reading 10 different answers

Real Talk: I probably saved 10-15 hours of googling, debugging, and trial-and-error just by having Copilot CLI help me with terminal commands, git operations, and understanding error messages.

If you're not using it yet, you're missing out! It's like having a senior developer on speed dial. 🎯

The Tech Magic Behind the Curtain 🎩✨

(Don't worry, I'll keep it light!)

Built With Love Using:

Next.js 14 (App Router)
Supabase (PostgreSQL database + storage)
TypeScript (because typos are for noobs)
Tailwind CSS + shadcn/ui (for that crispy dark mode 🌙)
Bun runtime (faster than your morning coffee hitting your system)

Security Layers:

Passwords: bcrypt hashing (can't crack it even if you try)
API Keys: AES-256-GCM encryption (Fort Knox level)
Document Passwords: Another layer of bcrypt (double protection!)
Organization Isolation: Complete data separation (no mixing allowed)

Document Support:

Upload pretty much anything:

PDF (with embedded viewer)
Word docs (auto text extraction!)
Plain text, CSV, Markdown
HTML, JSON, RTF, ODT
Even Excel and PowerPoint (why not?)

File size limit: 50 MB per document. That's like... a LOT of cat pictures! 🐱

The Boyfriend-Girlfriend Analogy That'll Make You Understand Permissions 💑

Let's say you and your partner are working on planning a surprise party:

User Role (You):

You can create your own to-do list
You can only see your own tasks
You can't see or touch your partner's secret guest list

Admin Role (Your Partner who's more organized):

Can see both your lists (within your organization)
Can delete tasks from User-level people
Can manage who's invited to the planning team
But can only see YOUR organization's party, not other orgs

Super Admin Role (The Senior Party Planner):

Like Admin but can also approve new members joining YOUR organization
Can promote people to Admin within your org
Has elevated privileges for your organization
But still can't see OTHER organizations' parties (that's God's job!)

God Role (The Person Whose Birthday It Is):

Knows about ALL surprise parties EVERYWHERE (cross-org access!)
Can access any planning doc in any organization for platform management
Can post announcements to all party groups at once
Bypasses all password locks (it's their birthday, after all!)
The ONLY role that can see across all organizations!
But remember: God is the platform administrator, not Big Brother watching everything. The focus is on managing public documents and cross-org coordination, while respecting organizational privacy.

See? Not so complicated! 😊

Real-World Use Cases

For Teams:

Store company policies (Organization classification)
Share meeting notes (Comment access)
Collaborate on proposals (Edit access)
Lock sensitive HR docs (Password protection)

For Content Creators:

Draft blog posts (Draft status)
Get feedback from editors (Assign reviewers)
Publish final versions (Published status)
Archive old content (Archived status)

For Students:

Store class notes
Collaborate on group projects
Share study guides
Keep research papers organized

Question for you: What would YOU use this for? I'd love to hear your use case! Drop it in the comments! 💭

The Journey (AKA The Fun Part) 🎢

Building this was like assembling IKEA furniture while blindfolded. Here's what I learned:

Challenge #1: Role-Based Access Control

Creating a system where User < Admin < Super Admin < God without breaking everything? HARD. I used a "weight" system (User = 10, Admin = 50, Super Admin = 75, God = 100). Simple math, complex implications!

Challenge #2: Organization Isolation

Making sure Acme Corp never accidentally sees Globex Inc's documents? I had to filter EVERYTHING by organization. Every. Single. Query.

Challenge #3: Encryption That Doesn't Break

Encrypting API keys is easy. Making sure you can decrypt them later? That's the trick! Used AES-256-GCM with unique IVs for each key. Sounds fancy, works perfectly!

Challenge #4: God's Multi-Org Publishing

When God creates a document for "All Orgs", the system:

Uploads the file ONCE to storage
Creates a document record for EACH organization
All records point to the same file
When God changes the status, ALL copies update together

It's like posting on all your social media at once, but harder!

The Tech Implementation (For My Developer Friends)

Permission Checking:

export function outranks(roleA: string, roleB: string): boolean {
  return getRoleWeight(roleA) > getRoleWeight(roleB);
}

export function isAtLeast(roleA: string, roleB: string): boolean {
  return getRoleWeight(roleA) >= getRoleWeight(roleB);
}

Simple, elegant, effective!

Document Deletion Logic:

User can delete: Own docs only
Admin can delete: Own + User docs (Admin outranks User)
Super Admin can delete: Own + User + Admin docs
God can delete: Own + any public document

AI Action Flow:

User clicks an AI action
System decrypts their API key in memory (never stored decrypted!)
Sends document content to AI provider
Returns result to user
Result NOT stored (privacy first!)

Organization Membership:

New user registers with Organization Code
Account created with "pending" status
Super Admin approves or rejects
If approved, user gets full access
If rejected, user can't log in

Clean workflow, no confusion!

Try It Yourself!

Live Demo: https://radhika-docmanager.vercel.app/

Documentation: https://radhika-docmanager.vercel.app/docs

Want to test it locally? Here's the speed run:

Clone the repo from GitHub
Set up Supabase project (free tier)
Copy .env.example to .env and fill in your credentials
Run bun install && bun dev
Visit http://localhost:3000/api/seed to get demo accounts
Log in and start creating documents!

Demo accounts (all use password Password123!):

god@system.local - God role (platform-wide access!)
superadmin@acme.com - Super Admin (approve memberships!)
admin@acme.com - Admin role (manage your team!)
user1@acme.com - Regular user (the everyday experience)

Or try the live app: radhika-docmanager.vercel.app

Check out the full documentation for setup details!

What's Special About This Project?

1. Security First

Most projects add security as an afterthought. I built it from day one. Encryption, hashing, isolation — the works!

2. No Vendor Lock-In

Your API keys, your choice. Switch providers anytime without losing data.

3. Real Enterprise Features

Multi-org support, approval workflows, audit logs, reviewer assignments — this isn't a toy project!

4. Actually Good UX

Dark mode that doesn't hurt your eyes. Clean interface. Logical workflows. I actually USED it while building it!

5. Named After Someone Special

Radhika's DocManager is named after Radhika Sharma. Built by Rohan Sharma (yes, it's me). Want to know more about Radhika? Find the secret page in my portfolio. ❤️

Rohan Sharma - Software Developer, Professional Blog Writer and UI/UX Designer

Explore the portfolio of Rohan Sharma, featuring cutting-edge software projects, insightful blogs, and creative UI/UX work.

rohansrma.vercel.app

6. Built with GitHub Copilot CLI

The entire development process was supercharged by GitHub Copilot CLI; from debugging complex database queries to writing deployment scripts. It's like pair programming with an AI! 🤖

Why This Project for the GitHub Copilot CLI Challenge? 🏆

This challenge is all about showcasing how GitHub Copilot CLI enhances the development process, and boy, did it ever!

The Challenge: Build an AI-powered, multi-tenant document management system with enterprise-grade security.

The Reality: That's A LOT of complexity; database schemas, encryption, role hierarchies, file uploads, organization isolation, and more.

The Solution: GitHub Copilot CLI became my development companion, helping me:

Debug complex SQL queries and foreign key constraints
Generate secure encryption keys and understand crypto operations
Navigate git operations when managing multiple feature branches
Understand error messages and fix bugs faster
Write deployment scripts and environment configurations

The Result: A production-ready application deployed at radhika-docmanager.vercel.app with features that would normally take months to build!

Without Copilot CLI, I would have:

Generate the entire Supabase schema from a single prompt describing my data model
Create Row Level Security policies for organization isolation automatically
Spent hours googling obscure error messages
Made security mistakes in encryption implementation
Struggled with git conflicts during feature merges
Wasted time reading documentation for every command

I've even implemented most of the frontend with it. Ehehe.

Instead, I focused on building features and solving real problems while Copilot CLI handled the "how do I do this?" questions instantly.

That's the power of AI meeting the command line! 🚀

Final Thoughts

Building Radhika's AI DocManager was a rollercoaster. There were moments of "WHY ISN'T THIS WORKING?!" and moments of "OMG IT ACTUALLY WORKS!"

But you know what? Creating something that helps teams manage documents securely while leveraging AI (without selling their soul to Big Tech) feels pretty amazing.

If you've made it this far, thank you for reading! You're awesome! 🌟

Star the Github Repo 🌠

Try the project, break it, suggest features, report bugs, I want to hear it all!

And if you're wondering why it's called "Radhika's DocManager", it's named after Radhika Sharma, someone special whose memory inspired this project. Sometimes the best projects come from the heart. ❤️

Links & Contact

Live App: https://radhika-docmanager.vercel.app/
Documentation: https://radhika-docmanager.vercel.app/docs
GitHub Repo: RS-labhub/AI-DocManager
My Portfolio: rohansrma.vercel.app
Email: rs4101976@gmail.com
LinkedIn: Rohan Sharma
X/Twitter: @rrs00179

Try the live app and let me know what you think!

Thank youuuuuuuuuuuuuuuu for reading! ❣️

Creating a Chatbot that actually Stands Out! (vibe coded version)🦖

Rohan Sharma — Thu, 29 Jan 2026 05:04:47 +0000

Hi there,

As I promised at the start of this year, I'm fulfilling my commitment. 😆

In this blog, I will discuss how you can create a chatbot far better than the rest of the other chatbots around. This blog is mostly for learning, so keep an eye at every section. I will be referencing the Chatbot I've created. Btw, my chatbot is called "Radhika", so I will call it by its name itself.

Radhika

Radhika is a versatile AI chatbot designed to assist with a wide range of tasks, from answering questions to providing recommendations and engaging in casual conversation.

radhika-sharma.vercel.app

Try it out, give feedback and suggestions, request changes, etc,.

It's open-source as well, so leave a github star if you loved it.

Note:
Switch to GROQ in case Gemini encounters an error. Currently, I'm using the free plan, so the tokens might get exhausted.

Let's start building our Chatbot!

Before doing anything else, decide on your tech stack.

There are many ways to build a chatbot, and plenty of stacks you can choose from. Pick the one you are most comfortable with.

For Radhika, I used TypeScript, which is a typed version of JavaScript. I built it using Next.js so both the frontend and backend live in the same project. This also makes deployment simpler since everything is deployed together. Simple and efficient.

(To be honest, vibe coding NextJS apps is easier, and the AI tools do a great job)

Design it.

If you're a designer, then design the bot in applications like Canva or Figma.

If you want to see Radhika's design, please check this radhika_figma_design.

If you're not a designer, describe the prompt as much as you can with all the details you've in your mind. Don't think about the features, think about the design.

Remember, our first target should either be the backend or the frontend. You can start with any of them, but I usually suggest creating the frontend first and then working on the backend.

For a start, I'm adding a sample prompt for this, but before that I need to cover an important question, i.e., WHERE TO ADD THIS PROMPT?

You can add the prompts to generate the frontend in these platforms:

But since we are going to create a full-stack chatbot, I suggest to use claude-opus-4.5 model in your IDE. And if you

If you're a student, try to avail the Github's Student Pack and then use your IDE + Github Copilot. (you'll get a hell lot of free credits to most of the models, including claude-opus-4.5 create anything good.)

Here's your GO TO PROMPT to build your first Chatbot:

### Agentic UI Replication Prompt (Design + Three.js + Maintainable Code)

You are a senior product designer and frontend engineer with strong experience in **scalable UI systems**, **Three.js**, and **long-term maintainable codebases**.

Your task is to replicate a **AI assistant ChatBot** with a **three-column layout**, glassmorphism, and subtle real-time visualizations, while keeping the implementation **clean, readable, and modular**.

## Core Principles

* Prioritize **readability over cleverness**
* Small, focused files
* Clear separation of concerns
* No duplicated logic
* All visuals, logic, and data flows should be easy to reason about

## Project Structure Guidelines

* Organize the codebase by **feature, not by file type**
* Each major UI section should live in its own folder
* Each folder should contain:

  * One main component
  * One styles file
  * Optional subcomponents
  * A clear entry point
* Three.js logic must be isolated from UI layout code
* Avoid large monolithic components

## Overall Visual Style

* Dark navy to near-black gradient background
* Glassmorphic cards with subtle blur and soft inner glow
* Rounded corners throughout
* Accent color: cyan / electric blue
* Premium, calm, futuristic AI aesthetic
* No harsh borders, no visual noise

## Left Sidebar (Assistant Identity + Modes)

* Fixed vertical glass panel
* Sections split into small components:

  * Assistant identity header
  * Mode selector list
  * Unlock CTA card
  * Quick actions list
* Active mode visually highlighted with soft cyan glow
* All icons and labels driven from a single config file

## Center Panel (Primary Interaction Area)

### Header

* Mode title
* Model badge
* Minimal action icons
* Primary CTA button
* Header logic isolated from content logic

### Core Visualization (Three.js)

* Use a dedicated Three.js scene module
* Render an abstract **circular particle system**
* Particles form a softly rotating sphere or neural cluster
* Color palette limited to cyan, blue, and soft white
* Animation:

  * Slow rotation
  * Subtle breathing or noise-based movement
* Interaction:

  * Light cursor-based parallax
* The canvas must be:

  * Self-contained
  * Easily removable or replaceable
  * Not tightly coupled to UI state

### Main Content

* Headline and subtext in a simple content component
* Quick action pills rendered from a data array
* No hardcoded UI strings inside logic

### Input Section

* Input bar broken into:

  * Text input component
  * Left action icons
  * Right action icons
* Icons reusable across the app
* Keyboard behavior handled in a dedicated hook or utility

## Right Sidebar (Analytics & Activity)

### Activity Matrix (Three.js)

* Separate Three.js scene from layout code
* Visualize activity using:

  * Nodes and connecting lines
  * Temporal motion paths
* Minimal neon wireframe aesthetic
* Motion should feel ambient, not informational
* Scene must support pausing when off-screen

### Stats & Mode Usage

* Each stat card as its own component
* Mode usage bars driven by data, not hardcoded values
* Visual styles shared via common tokens

### AI Status Section

* Reusable status row component
* Indicator colors derived from state mapping
* No inline conditional styling

## Three.js & Performance Constraints

* Keep particle counts low and configurable
* Centralized animation loop management
* Clean disposal of geometries and materials
* requestAnimationFrame usage should be controlled and predictable
* WebGL failure should gracefully fall back to static UI


## Maintainability Constraints

* No inline styles for complex layouts
* No deeply nested components without justification
* Use clear naming conventions
* Comments should explain intent, not obvious behavior
* Any complex logic must be documented at the top of the file

## Final Goal

The result should feel like a **production-ready AI dashboard** that is:

* Visually calm
* Technically elegant
* Easy to extend
* Easy for another engineer to understand within minutes

Make some iterations until you reach a satisfactory level. (Satisfaction doesn't mean you need the best out of the best. It should be something you think is good enough)

Start implementing the Core Features

And since we are creating it through vibe coding, let's go through a little-little code only. Want no code? Skip this section.

In your chatbot, you can add multi-provider support or you can choose only a single provider. In my case, I love to have multi-provider support because this allows the user to switch to any model they want.

The following diagram represents the implementation I've done in Radhika:

But the most important part than this is to parse the request sent by the user.

The request handler begins by parsing the JSON body from the incoming POST request:

const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;

messages: The conversation history sent by the client.
mode: Determines which system prompt to use (e.g., bff, learning, etc.). // totally depends on you if want to add multiple modes
provider: Specifies the AI backend to use (groq, openai, claude, gemini, or whatever provider you're using).
apiKey: Required for OpenAI and Claude if a user key is needed.

Assign the Prompt
Add a system prompt on how you want your chatbot should behave and talk about. You can also link it with a KB (knowledge base) or create your own mini knowledge base to make your bot more specific to something.

I've not implemented this as I wanted my Radhika to be generic and serve as a good template for someone like you.

If you're also adding multi-provider, then route to the correct provider. Each provider has custom logic to instantiate the model, handle errors, and stream the response using:

await streamText({...})

Looking for a prompt? Here it is: (add this in the same chat session or the create one)

### Agentic Backend Architecture Prompt

You are a senior backend engineer designing a **production-ready AI chat backend** with **multi-provider model support**, clean architecture, and long-term maintainability.

Your goal is to build a backend that powers an AI assistant similar to **Radhika**, where users can switch models dynamically while keeping the system simple, extensible, and readable.

## Core Backend Principles

* Clear separation of responsibilities
* No provider-specific logic inside request handlers
* Easy to add or remove AI providers
* Streaming responses by default
* Minimal abstractions, no over-engineering
* Code should read like documentation

## Request Handling Flow

* Use a single POST endpoint for chat interactions
* Parse the incoming JSON request at the boundary

`'``ts
const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;
`'``

* `messages`: full conversation history from the client
* `mode`: determines which system prompt to apply
* `provider`: selected AI backend
* `apiKey`: optional user-supplied key for providers that require it

Validation should happen immediately after parsing and fail early with clear errors.

## Prompt Management

* System prompts must be centralized
* Store prompts in a dedicated module or folder
* Map prompts by mode name
* Avoid hardcoded prompt strings inside logic
* Allow future expansion into:

  * Knowledge base injection
  * Context enrichment
  * Mode-specific behavior tuning

If no custom knowledge base is attached, default to a generic assistant prompt suitable for broad usage.

## Provider Routing

* Use a provider router layer
* Route requests based on the `provider` field
* Each provider must live in its own isolated module
* No shared state between providers

Each provider module should:

* Instantiate its own client
* Normalize input messages
* Handle provider-specific errors
* Support streaming responses using:

`'``ts
await streamText({ ... })
`'``

The request handler should never know how a provider works internally.

## Streaming Architecture

* Streaming must be first-class, not optional
* Keep streaming logic abstracted behind a common interface
* Providers should emit tokens in a unified format
* Handle disconnects and stream cleanup gracefully

## File Organization Guidelines

* Organize by responsibility, not file type
* Suggested structure:

  * `/routes` for request handlers
  * `/providers` for AI provider implementations
  * `/prompts` for system and mode prompts
  * `/utils` for shared helpers
  * `/types` for request and provider contracts
* One provider per file
* One responsibility per file
* No oversized files

## Error Handling

* Normalize all provider errors
* Never leak raw provider error messages to clients
* Return consistent error shapes
* Log provider-specific details internally

## Extensibility Rules

* Adding a new provider should require:

  * One new provider file
  * One registration entry in the provider router
* No changes to the core request handler
* No breaking changes to existing providers

## Maintainability Constraints

* Avoid deeply nested conditionals
* Prefer early returns
* Use explicit naming over clever abstractions
* Add comments only where intent is non-obvious
* Keep configuration and logic separate

## Final Goal

The backend should feel like a **reference implementation** that:

* Supports multiple AI providers cleanly
* Streams responses efficiently
* Is easy for other developers to fork
* Serves as a strong template for building AI chat systems

Adding a Database (optional)

Though this is totally optional, if you want to add persistent storage to the user chats that can be retrieved later, then add a database. Or if you want to track your bot users, you can create a database.

I used it to implement both.

Initially, I was using the Supabase free tier, but I was hitting the limits, and my app was becoming stale. Then I switched to Appwrite. Both are totally different; one is SQL, while the latter one is NoSQL. Although use node-appwrite package to skip the manual schema add-ons.

If you want to create something similar to what I've created, then modify or replicate setup_appwrite_schema.

Looking for a prompt? Think your logic first and write it, and then ask ChatGPT to convert it into an agentic prompt. You will enjoy this!

You're so done!

This is how simple to create a full-fledged chatbot with a professional codebase.

Once done, you can upload it to GitHub and then host it on serverless platforms like Vercel.

If that's not enough to you, then start with Radhika and modify as much as you can.

RS-labhub / Radhika

Radhika is a multi-model AI assistant built for your mood and friendship 💞

Radhika

A modern AI assistant that adapts to how you work and think. Multiple modes, multiple models, one seamless chat experience. Features multiple LLM providers, image generation, voice interaction, and persistent chat history.

Try now: https://radhika-sharma.vercel.app

Detailed Explanation

Preview	Description
	Blog Post Read the blog for in-depth explanation.
	YouTube Demo Coming soon.

Features

6 Chat Modes: General, Productivity, Wellness, Learning, Creative, BFF
Multi-Provider LLM: Groq, Gemini, OpenAI, Claude
Image Generation: Pollinations, DALL·E 3, Hugging Face, Free alternatives
Voice: Speech-to-text input & text-to-speech output
Auth & Persistence: Appwrite auth with chat history & favorites
UI: Light/dark themes, modern & pixel UI styles

Quick Start

git clone https://github.com/RS-labhub/radhika.git
cd radhika
bun install   # or npm install
bun run dev   # or npm run dev

Open: http://localhost:3000

License

MIT License - see LICENSE

Built with ❤️ by Rohan Sharma

⭐ Star • 🐛 Issues • 🗣️…

View on GitHub

I have implemented a lot of other features like voice recognition and synthesis using WebKit and Eleven Labs, image generation using pollination.ai, openai, gemini, huggingface models, etc,. (pollinations ai and HuggingFace models are free to generate images/videos/texts/etc,.)

Conclusion

Creating a chatbot is super-easy and doesn't need much knowledge. It's just like texting messages to agents.

However, you need prompting skills to get the product in a very less time.

Want some prompting tips? Comment or reach out to me!

Before sharing the ways to reaching me, I want you to star the GitHub repo of Radhika.

Star Radhika on Github 🌠

Find the Live Demo here: https://radhika-sharma.vercel.app/

Want to connect with me? Visit my Portfolio, contact's page.

2025 in Review: Growth, Grief, and the Cost of Momentum

Rohan Sharma — Wed, 31 Dec 2025 04:15:22 +0000

Hey there,

I know, I know it's been a long time since I last posted or wrote anything. It might be possible that you are either pissed off at me or have literally forgotten me. In both cases, I apologize.

So, why was I dead? Possible reasons:

being very very very busy at work
being depressed
lost willingness to write
lose interest in everything
no reasons, just trying to coverup myself with lies

Before you go ahead and read the rest of the blog, please select an option from above and write it down in the comment section. Let's see what you think!

Let's start this blog by justifying myself.
The actual reason for me being dead was -- several. I will write my 2025 wrap-up and then wind up the reasons if you still didn't get it while reading it.

Starting with January 2025. The year began with a big change. I joined LLMWare as a devRel Engineer and am still serving to Quira as Community Moderator. February was already on my mind because of the GATE exam (a national exam in India for PG admissions). So, I also started to prepare for that. The weather stayed kind, which helped more than I realized at the time. Oh btw, I forgot, I went to college every day just to reach the 75% attendance milestone/.

February 2025. This was the month things started to feel real. I had the GATE exam in the first week, and once it was over, I shifted fully back to work. I had taken quite a few days off earlier and did not want to slow things down further. On February 8, 2025, I consciously decided to make llmware my P0 and commit to it properly. A few days later, my university exams began. It was work during the day and exams around it. I managed. In the middle of all that, I lost something I can never get back - a friend. It was 16th Feb, 2025.

After a rough start, 2025 rolled into March. Things began to move with more seriousness. I started giving more of my time to work. College was sucking, as usual. Staying busy became a way to escape the matrix of overthinking. Along the way, I missed a few family moments, and by the end of the month, my brothers left home for work. For the first time, the house was quiet. Not for a day, but for DAYS. Professionally, things were on track. Personally, I was starting to fall behind.

April 2025 started. llmware started gaining real momentum on GitHub. Work became my default state. I began keeping my distance from people and spending more time alone. During the month, I met the Founder & CEO of devEco. We had a few meaningful conversations, and I decided to take on part-time work with them.

It's May 2025 now. Things accelerated at llmware. I was putting in more hours than ever. Alongside that, I officially joined devEco as well. Suddenly, my days were split between college, llmware, quira, and devEco. Even then, most of the conversations were still with myself. With still some time left to spare, I pushed myself to participate in a DEV Challenge, the authorization challenge.

Now, it's June 2025, the biggest month for me. I pushed past every limit and worked relentlessly. On non-college days, I was putting in 14 to 15 hours. On college days, around 8 to 9. I led the documentation for llmware’s major product announcement, Model HQ. The work spanned two months, but most of it came together in June. I also won the DEV Challenge I had participated in the previous month.

Professionally, I was at my peak. And it was at that peak that I started forgetting everything else. I barely ate because I simply did not think about it. The intensity was self-imposed. There was no pressure from either company. In fact, I was repeatedly asked to slow down and rest. I did not listen. During this stretch, I also wrote five blogs and scheduled them through early July.

Sadness followed me through it all. When the Founder & CEO of Quira told me the company was winding down, it shook me deeply. Quira was my first job, and the place where I learned how to build and belong.

July 2025 started with university exams. I slowed down at work, not because of the exams, but because I was quietly losing interest, even though I kept showing up and delivering. Exams themselves never bothered me much. What weighed heavier was going to college every day. I am a one nighter. I usually study for three to four hours and then sit for the exam. Somehow, I cleared everything with zero backlogs.

Quira was officially closed now. I gifted the Founder & CEO with this. He loved it.

Around the same time, one of my brothers decided to resign from his job. He was struggling with the food and climate of the region, and it had finally caught up with him.

August 2025. Happiness began to return, slowly. My brothers came back. One for good, to prepare for what was next, and the other just for the holidays. I was still hoping for a comeback from that friend, but it never happened. The hardest part was seeing each other every day in college, like strangers.

I started working again like a normal human being, and for the first time in months, I had some spare time. Around then, a former DevRel from Quira reached out and asked if I could help at his current company. He was someone who had taught me a lot. I knew he did not really need help. He was trying to help me instead. I did not say no.

That is how I joined Tessl as a part-time DevEx Engineer. Once again, I was working with three companies. This time, the work was different, harder, and more demanding in its own way. I stopped thinking too much about myself and kept moving forward.

My birthday month, September 2025. I was born on September 1. Fun fact, World War II also officially began on that day. Strange coincidence. Overall, it was a good month. I enjoyed working at my new company, even though it was more demanding than anything I had done before. I had never worked with so many people at once. The team at Tessl is filled with well-known names, and I genuinely loved being part of it. Life felt steady again.

October 2025. This was the first month when I didn't work at llmware at all. Things were moving internally, and we were all waiting. I ended up with a break, but I did not really stop. I started working on something else, still under wraps (yes, a secret). I also updated one of my projects, Radhika, and launched version 2.0. By the way, version 3.0 is coming in a few days as well. The month was also filled with festivals, and for once, I celebrated them properly.

And it's November 2025, another exam month. I slowly resumed work with llmware, tessl, and devEco continued as usual. But somewhere along the way, I lost interest in work itself. It started to feel boring. I had my 3rd university exam this month. Around this time, something shifted in me. I stopped feeling much of anything. No excitement, no fear. Just a quiet numbness. My circle became smaller than it had ever been. But overall, it was good.

Lastly, December 2025. I was fully back at work, almost like before. This time, though, I had more holidays than usual. I am still on break until January 1, 2026. The time off did something unexpected. It forced me to notice what I had lost this year, what I wanted but never paused to ask for. Loneliness showed up quietly. Real FOMO too. Feelings I had avoided all year finally caught up.

At this point, I cannot clearly say whether I am happy, sad, exhausted, lost, or simply alone. Maybe it is a mix of everything.

Have you ever gone through a phase like this?

Now's let me write what you're most interested in reading

Leaving personal life in a corner, let's talk about the professional growth I've achieved this year.

Building Community and Trust at Quira:

Engaged in activity and participation in Quests
Handled the community in hard times.
Helped many members get started and ship their first projects on Quira through one-on-one sessions.
Proposed ideas that significantly improved community participation, communication, and retention.
Built a warm and approachable community space where members felt comfortable reaching out. I was never seen as a distant or formal figure, but as a trusted colleague, which I truly valued.
Demonstrated strong developer advocacy by supporting both the product and the people using it.

What I Built and Shipped at LLMWare:

Elevated LLMWare's GitHub activity. (6,500+ Stars and 2,000+ Forks Organic Farming in 6 months)
Increased the awareness of SLMs.
Created a whole new website. (A newer version is coming soon)
Wrote documentation for Model HQ (a llmware's product) and hosted it. (got great feedback from senior developers)
Involved in QA and testing of Model HQ.
Delivered over 15 high-quality contents.
Contributed to the social presence of llmware.

Growing devEco's Developer Presence:

Managed socials across multiple platforms for devEco, devEco products, and devEco clients.
Achieved a great percentage of increase in activities like reactions, comments, reposts, and impressions.
Sparked active conversations through thoughtful content, up from almost none.

Strengthening the Developer Ecosystem at Tessl:

Strengthened the AIND ecosystem by improving the Landscape platform, fixing major bugs, refining categories, and adding new tools consistently.
Enhanced content operations through automation projects and streamlined publishing workflows.
Delivered high-quality research, carousels, and weekly trending tool updates that improved visibility and engagement across developer channels.
Provided cross-functional support to improve UX, data quality, scraping workflows, and overall product reliability.

I am sure I have not captured everything here, and that is okay. What matters is that I know how much I worked, and that I gave my best to everything I was part of. I do not know if I will continue on the same path, but for now, I am not worried about it.

Things I loved the most!!!

There were a lot of moments this year that I loved a lot. Let's start!

At Quira, I did not just meet people. I made a real friend circle. And I believe this deeply: when someone reaches out to you as a friend and shares their feelings and pain points, it means you have occupied a special place in their heart. That feeling is rare, and I will always value it.

LLMWare. Ahh. I honestly do not have enough words for this one. I met some incredibly sharp senior developers through LLMWare. Since I am under NDA, I cannot share much, but this experience opened doors to many Silicon Valley giants for me. More importantly, this was the first time I worked on a real product at a very early-stage startup. Working closely with the CEO and CTO felt natural and calm. They are kind, thoughtful, and genuinely great people to work with.

devEco filled me with sessions of laughter, joys, arguments, and whatnot! The founder is insanely cool and welcomes everyone with warmth. Becoming a core devEco member is a different kind of fun. He talks to me, teaches me, appreciates me when I do something right, and corrects me when I make mistakes. Interestingly, I didn't made much mistakes. I have 90% appreciation in my hands. Ehehe. But I must say, meet with this human once and you won't regret it.

Tessl was the biggest surprise. I was honestly hesitant at first. There were a lot of people, and in the past, I had only worked with 3 or 4 at a time. Being a newbie in such an environment hits differently. But guess what. It was smooth. Really smooth. A huge thanks to the DevRel at Tessl. This guy taught me a lot and supported me constantly. He is the person I feel most comfortable with. I can even talk to him about my personal life with ease. He speaks, shares ideas, listens to ideas, has zero ego or arrogance, treats everyone equally, always helps others, travels way too much, and still manages everything.

And not just him. The entire Tessl team is welcoming and amazing. I even got to work with the Father of DevOps himself, and he even appreciated my work(ehehe). That one stays with me.

What I Achieved!!!

Well, I achieved a lot of things. But there are some things beyond work that matter just as much.

I know most of you want to know how much money I made. Of course, I am not going to tell that. But you can assume. Let me know in the comments. I will say this though. I earned a good amount. And now, I want more. I already have plans for 2026. Or maybe not. I am a moody guy. My plans change often.

Apart from money, I gained a lot. We renovated our house. It is still not fully done. Two more months to go. We also bought a lot of furniture, although that part feels less special since we already have a family business around it.

I also got my Aloo (Mr. Potato). See below. Cute, right? Thanks to Cloudinary.

Beyond money and things, I earned something better. Respect. Trust. Value. Most importantly, I unlocked an intense learning mode. Once it switches on, it is hard to turn off.

Seems like I told everything I needed to tell. For those who still want to know the actual reason for my being dead are:

I lost my interest in almost everything.
Doing work is now boring for me.
I was a bit sad.

I do not want to write everything again, and I do not want to summarize it either. But somewhere above, these were the reasons.

Before ending, I want to thank my friends. I will not take names properly, but if you are reading this, you already know who you are.

Thanks to my college friend, SK. Without him, I would never have cleared my college exams or survived college life. We spent almost all our time together. Being single, searching for someone, then running away. He can be brainless, but not brain-rotted. A good guy with intense slang specialization.
Thanks to HG. A person I have never met in real life. But if you are not in a good mood, one single text can turn into World War III. Good, kind-hearted, always listens. Extra thin and weak human. I will not say much, else WW IV will start. But thank you for always being there.
Thanks to Sam for being Same Sam. Ultimate mad and animal human. I do not know what to say about you. Take care, you sick human. And thanks for being there.
Extending my gratitude to Dishu and Piliya. Both are placed. Both are talkative. Both get angry for no reason. Both are kind and always text me for anything. Also, neither is a cute human. Thank you, guys.
Thanks to my elderly sister NG as well. Overaged person with professional traumas. Best in arguments and worst in winning them. LOL. Thank you.
And the last guy, KOS. I worked with him. We talked about work for 1% of the time and movies, series, and heroines for 99%. Thanks for helping me debug bugs that were already fixed.
Thanks to SK as well, whom I lost this year. You've helped me a lot. Those were the happy days. Happy life ahead!

Again, do not take my words too seriously. But if you do, you are already a great person 😂

Thanks for being there.

Before I wrap this up, one last thing.

If you ever feel like knowing more about me, or just want to talk about work, life, random ideas, or nothing in particular, you can reach out to me anywhere below. I am usually around, and I genuinely enjoy conversations more than formal networking.

My portfolio: https://rohan-sharma-portfolio.vercel.app
X: https://x.com/rrs00179
LinkedIn: https://www.linkedin.com/in/rohan-sharma-9386rs/
GitHub: https://github.com/RS-labhub

No pressure to follow or connect. Just putting this here.

That is all from my side. Thank you so much for reading till here. I will be active from next year and keep delivering good content.

I forgot to ask, how did your year go?

How to Create a Local Chatbot Without Coding in Less Than 10 Minutes on AI PCs

Rohan Sharma — Wed, 02 Jul 2025 04:10:07 +0000

🔖 No cloud. No internet. No coding.
🔖 Just you, your laptop, and 100+ powerful AI models running locally.

Imagine building your own chatbot that can answer your questions, summarize documents, analyze images, and even understand tables, all without needing an internet connection.

Sounds futuristic?

Thanks to Model HQ, this is now a reality.

Model HQ developed by LLMWare, is an innovative application that allows you to create and run a chatbot locally on your PC or laptop without an internet connection. Best of all, this can be done with NO CODE in less than 10 minutes, even on older laptops up to 5 years old, provided they have 16GB or more of RAM.

In this guide, we’ll walk you through how to create your own local chatbot using Model HQ ; a revolutionary AI desktop app by LLMWare.ai. Whether you’re a student, developer, or a professional looking for a private and offline AI assistant, this tool puts the power of cutting-edge AI models directly on your laptop.

Let’s break it down.

If you want to know about Model HQ in detail, then read the blog below:

Rohan Sharma for LLMWare

Jun 27 '25

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

#showdev #ai #security #nocode

Comments 17

5 min read

Step 1: Download Model HQ

Model HQ is an AI desktop application that allows you to interact with over 100+ top-performing AI models, including large ones with up to 32 billion parameters — all running locally on your PC.

Unlike cloud-based tools, there’s no internet required, and your data never leaves your machine. That means more privacy, better speed, and zero cost for each query you run.

In this blog, we will be looking into the CHAT feature of Model HQ that helps us to create a chatbot running locally on our machine.

First, get the app.

👉 Download or Buy Model HQ for Windows

Not ready to buy? No problem.

👉 Join the 90-Day Free Developer Trial

Once installed, you’ll have access to an interface that feels like your own AI control panel.

Step 2: Choosing the Right AI Model

Once installation is done, open the ModelHQ application, and then you will be prompted to add a setup method. The setup guide is provided after buying the application.

After this, you will land in the main menu. Now, click on the Chat button.

You’ll be prompted to select an AI model. If you’re unsure which model to choose, you can click on “choose for me,” and the application will select a suitable model based on your needs. Model HQ comes up with 100+ models.

Available Model Options:

Small Model:
~1– 3 billion parameters:- Fastest response time, suitable for basic chat.
Medium Model:
~7– 8 billion parameters:- Balanced performance, ideal for chat, data analysis, and standard RAG tasks.
Large Model:
~9 – up to 32 billion parameters:- Most powerful chat, RAG, and best for advanced and complex analytical workloads.

By the way, Model HQ will pick a smart default based on your system and use case.

The size of the model you choose can significantly impact both speed and output quality. Smaller models are faster but may provide less detailed responses. Follow this simple rule:

Step 3. Downloading Models

For demonstration purposes, we are selecting the Small Model.

If no models have been downloaded previously (e.g., in the No Setup, Fast Setup, or Full Setup paths), the selected model will begin downloading automatically.

This process typically takes 2–7 minutes, depending on the model you selected and your internet speed.

This is only a one-time internet requirement; once the models are downloaded, you don’t need internet anymore.

Step 4: Start Chatting

Once you’ve selected a model, you can start a chat by typing in your questions. For example, you might ask a simple question like, “What are the top sites to see in Paris?” The model will generate a response based on its training data.

Customizing Your Chat Experience

Model HQ allows you to customize your chat experience further. You can adjust settings such as the maximum output length and the randomness of the responses (known as temperature). By default, the app is set to generate up to 1,000 tokens, which is usually sufficient for smaller models. However, even if you’re using larger models, be cautious about increasing this limit, as it can consume more memory and take longer to generate responses. So, in short, you can adjust generation settings:

Max Tokens: How long should the response be?
Temperature: Should the answer be creative or precise?
Stop/Restart: Hit ❌ to stop a long generation anytime.

Step 5: Integrating Sources for Enhanced Responses

One of the standout features of Model HQ is its ability to integrate sources, such as documents and images, into your chat. To do this, simply click on the “source” button and upload a file, such as a PDF or Word document.

Example: Using a Document as a Source

For instance, if you upload an executive employment agreement, you can ask specific questions about the clauses within the document. The model will reference the uploaded document to provide accurate answers. This feature is invaluable for fact-checking and ensuring that you have the right information at your fingertips.

Chatting with Images

Model HQ also allows you to chat with images. By uploading an image, the application can analyze the content and answer questions based on what it sees. This capability opens up a world of possibilities for multimedia processing, all done locally on your machine without any additional costs.

Step 6: Saving and Downloading Results

After you’ve finished your session, you can save the chat results for future reference. This is particularly useful if you need to compile information for reports or presentations. Simply download the results, and you’ll have everything you need at your fingertips.

Step 7: Exploring Advanced Features

As you become more comfortable with Model HQ, you can explore its advanced features. For example, you can experiment with different models to see how they perform with various types of queries. You can also adjust the generation settings to fine-tune the responses based on your specific needs.

If you’re a visual learner, then watch this YouTube walkthrough:

Future Updates and Community Engagement

Stay engaged with the Model HQ community by following their updates and tutorials on platforms like YouTube. The Model HQ YouTube playlist offers valuable insights and tips to help you maximize your experience with the application.

Join the LLMWare’s Official Discord Server to interact with LLMWare’s great community of users and if you have any questions or feedback.

Why This Matters

Most AI apps require you to upload data to a cloud server. That’s slow, often expensive, and puts your privacy at risk.

With Model HQ, everything runs on your own machine with:

✅ No internet needed
✅ No Coding Required
✅ No API keys or credits
✅ No data leaves your PC
✅ Zero cost per query

It’s your personal AI lab, fully private and offline.

Conclusion: Get Started with Model HQ Today!

Creating a chatbot that runs locally without coding and an internet connection has never been easier. With Model HQ, you have access to a powerful AI tool that can enhance your productivity and streamline your workflow.

Ready to experience the future of AI? Visit the LLMWare website to learn more about Model HQ and its features. Don’t forget to sign up for the 90-day free trial for developers here and explore the application firsthand. When you’re ready to make the leap, you can purchase Model HQ directly here.

Unlock the full potential of AI on your PC or laptop with Model HQ today, and take the first step towards creating your very own local chatbot!

Here's how I created a Real-Time Discord Badge for Github Readme 🌠

Rohan Sharma — Tue, 01 Jul 2025 03:30:03 +0000

Hello all, I'm back with another project. This time, I built a Real-Time Discord badge that shows the total member count.

In this blog, I will share with you:

Why did I build this?
Why add a dynamic Discord badge to your GitHub Readme?
A step-by-step guide to adding this badge to your GitHub README, including how to customize it.
How I handled real-time Discord data, added Redis caching, managed rate limits, and made it fast.

So, let's start. 3... 2... 1... 🌱

Why did I build this?

I want to tell you a super short story for this. The company for which I'm working wanted me to add a dynamic Discord badge to their GitHub README that shows the total member count.

I tried searching on the web. After a lot of searching, I found that Discord already provides a "Server Widget JSON API". For this, you have to go to your Discord server settings > engagement, and then turn on the widget, and you will be able to find the API link and the Server ID.

You can create a badge using this Server ID as shown below:

[![demo](https://img.shields.io/discord/YOUR_SERVER_ID?logo=discord)](https://discord.gg/INVITE_CODE)

But the thing is, it will only show the online members count and not all the members.

I tried to search a lot about "how to show all members' count", but I wasn't able to find any.

And thus, I decided to create one. It was super easy. When I built it for my company, I realized there may be more people who want this badge as well, so I made it public for the community.

I don't know if such badges are already there in the market or not. I tried to find a lot, and the disappointment made me build it. If you know any such badges or methods to show dynamic Discord badges that update in real-time, then please let me know in the comment section.

Why add `Discord Live Members Count Badge` to your GitHub Readme?

Many open-source projects and communities wanted to showcase their Discord server growth on their GitHub READMEs because:

The bigger the community, the more trust it builds. Thus, showing your total Discord members count will not only market your product, but also build trust in future users.
Real-time metrics make your README dynamic. It gives a sense that the project is active and maintained.
Attracts contributors and collaborators. A growing community signals engagement, which can draw in more developers.
Helps community managers track growth. Badges provide a quick glance at server stats without needing to log into Discord.
Encourages more users to join. Seeing a badge with large numbers can trigger FOMO and boost Discord join rates.
Improves project credibility. Just like stars and forks, community size becomes a social proof metric.
Easier comparison between similar projects. Potential users can quickly evaluate community support through visible numbers.

And the most important point, "SNEAK-PEEK YOUR RIVALS OR ENEMY, OR FRIEND DISCORD COMMUNITY MEMBERS". I don't know about you, but I do it. All you need is their Server ID. Keep reading the blog, and I will tell you how to do this. (I'm not promoting any such activities. It's bad. Anyway, I don't care. 😂)

Step-by-Step Guide: Adding `Discord Live Members Count Badge` to Your GitHub README

Let's get your Discord badge up and running in less than 5 minutes!

Step 1: Add the `Live Count Bot` to Your Server

First, you need to invite my bot to your Discord server:

🤖 Click here to add the bot

The bot needs minimal permissions:

View Channels (to access your server)
Manage Channels (for member counting)

Step 2: Enable Server Widget

This is crucial - without this step, your badges won't work!

Right-click your server name → Server Settings
Navigate to Engagement → Server Widget
Toggle ON the "Enable Server Widget" option
Copy your Server ID (you'll need this!)

Still facing difficulty? Follow the Documentation here

What if you're not a core member of the Discord server? The above option is present only for the server owner, admins, and moderators (sometimes). But if you're none of them and still want to add this badge? Remember, I told you above the "Sneak-Peek" thing? We will apply it here.

If you're not a core member and still want to add this badge or want to sneak peek, then follow the steps below:

Open your Users Settings
Navigate to Advanced
Toggle ON the "Developer Mode" option
Now, right-click on any server and you will get an option to Copy Server ID

NOTE: The Live Members Count must be present in that server.

Step 3. Customize your Badge

Let's make it fast and as simple as possible.

Copy this template, add your Server ID and Invite Link(optional, but important) in the corresponding places, and paste it in your GitHub Readme.

[![discord members](https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID_HERE)](https://discord.gg/YOUR_NEVER_EXPIRY_INVITE_CODE_HERE)

It will show the total Discord member counts (including the bots).

I have made multiple endpoints, check it out here:

You can check the endpoints using this link:

Discord Members:

  https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID_HERE

2. Discord Bots:

  https://discord-live-members-count-badge.vercel.app/api/discord-bots?guildId=YOUR_SERVER_ID_HERE

3. Discord Total:

  https://discord-live-members-count-badge.vercel.app/api/discord-total?guildId=YOUR_SERVER_ID_HERE

But, do you like to customize it more??
Well, I have this. I have included three extra parameters to make it more customizable for you.

color (optional) - Hex color without # (default: 7289DA)
label (optional) - Custom text label (default: varies by endpoint)
scale (optional) - Size multiplier from 0.5 to 10.0 (default: 1)

You can use them as:
Badge Code:

[![discord members](https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID&color=27ae60&label=Users&scale=2)](https://discord.gg/your-invite)

Endpoint:

https://discord-live-members-count-badge.vercel.app/api/discord-members?guildId=YOUR_SERVER_ID&color=27ae60&label=Users&scale=2

Output:

Same for other endpoints. Btw, pink is my favorite color. I don't know why I created a green badge. Maybe the devil made me do it.

There's a possibility that you might get frustrated because you have to change the color and scale multiple times to get your best. Each time, you have to wait for the page to reload or hit enter.

To become your HERO again, I built the website too.

Discord Badge

Add beautiful, real-time Discord member count badges to your GitHub README

discord-live-members-count-badge.vercel.app

The interface is simple. But there are two things to be noticed:

1. Badge Generator

This is simple, add your Server ID and Invite Link. Click on Generate, and your badges will be generated. Copy and paste it directly into the readme.

2. Interactive Playground

Don't want to manually customize badges? I built an interactive playground where you can:

🎨 Pick colors from presets or use custom hex codes
📝 Edit labels with live preview
📏 Adjust scaling with a visual slider
📋 Copy ready-to-use markdown code

🚀 Try the Playground

How did I build it?

In this section, I will try to explain how I built this web application.

Step 1. Creating the Discord Bot

Go to Discord Developer Portal
Create a new application
Go to the Bot section
Create a bot and copy the token
Invite the bot to your server with these permissions:
- View Channels
- Manage Channels

In Privileged Gateway Intents, Presence Intent and Server Members Intent must be enabled.

Bot Permissions
For this case, the bot needs minimal permissions:

View Channels (1024)
Manage Channels (16)

Total permission integer: 1040

Step 2. Routes and API

`discord-members` API

It fetches the approximate member count using Discord's /guilds/{guildId}?with_counts=true endpoint.

const r = await axios.get(`https://discord.com/api/v10/guilds/${guildId}?with_counts=true`, {
  headers: { Authorization: `Bot ${process.env.DISCORD_BOT_TOKEN}` },
});

*Caching * is not implemented in this route due to the approximate and fast nature of the API call.

`discord-bots` API

It counts bots in a guild using the fetchAllMembers() utility.

const members = await fetchAllMembers(guildId);
const botCount = members.filter((m) => m.user.bot).length;

Key Points:

Calls Discord's /guilds/{guildId}/members endpoint (paginated).
Requires member intent (Privileged Intent must be enabled).
Filters bot users using m.user.bot.
Uses caching to reduce repeated heavy calls. (in utils)

`discord-total` API

It combines both bot and human user counts.

const members = await fetchAllMembers(guildId);
const botCount = members.filter((m) => m.user.bot).length;
const humanCount = members.length - botCount;

Key Points:

Same logic and fetching as discord-bots.
Shows combined info like 22 users, 5 bots.

`fetchAllMembers` Utility

Paginate through all members of a guild using Discord's API.

while (keepFetching) {
  const res = await axios.get(`https://discord.com/api/v10/guilds/${guildId}/members`, {
    headers: { Authorization: `Bot ${DISCORD_BOT_TOKEN}` },
    params: { limit: 1000, after },
  });
  ...
}

Caching:

Tries Redis first using key guild:{guildId}:members.

  if (redis) {
    try {
      const cached = await redis.get(cacheKey);
      if (cached) {
        console.log(`[Cache] HIT for ${guildId}`);
        return JSON.parse(cached);
      } else {
        console.log(`[Cache] MISS for ${guildId}`);
      }
    } catch (err) {
      console.warn(`[Cache] Redis error on GET: ${err.message}`);
    }
  }

On cache MISS, fetches from Discord and caches the result.
TTL is controlled via CACHE_TTL environment variable (default 300 seconds).

Rate Limiting Handling:

If API responds with 429, waits for retry_after seconds, and retries.
Adds setTimeout between requests to avoid hitting limits.

if (err.response?.status === 429) {
  const retryAfter = err.response.data?.retry_after || 1;
  await new Promise((r) => setTimeout(r, retryAfter * 1000));
  continue;
}

Badge Generation

All routes use the badge-maker package:

let svg = makeBadge({
  label,
  message,
  color,
  style: 'flat',
  logoBase64: `data:image/svg+xml;base64,${discordLogoBase64}`,
});

Scaling: Optional scale param adjusts badge size.

if (scale !== 1) {
  svg = svg
    .replace(/<svg([^>]+?)width="(\d+)" height="(\d+)"/, ...)
    .replace(/<svg[^>]*>/, `$1<g transform="scale(${scale})">`)
    .replace(/<\/svg>/, '</g></svg>');
}

Error Handling: If any call fails, a red "error" badge is returned.

Quick Summary

discord-members = fast estimate, no intents.
discord-bots & discord-total = precise, uses member list and cache.
fetchAllMembers handles paging, rate limits, and caching.

The setup supports scaling, CDN caching, and proper Discord rate limit compliance.

Step 3. Create UI and Deploy.

You can use any AI tool for creating the UI. I used V0 by Vercel. Also, for deploying my application, I used Vercel.

See it in Action

Check out the GitHub repository for the Source Code (liked this project? Star it 🌠):

RS-labhub / Discord-Live-Members-Count-Badge

Add beautiful, real-time Discord member count badges to your GitHub README

🎯 Discord Live Members Count Badge

Add beautiful, real-time Discord member count badges to your GitHub README

✨ Features

🔄 Real-time Updates - Live member count with smart caching (5-minute intervals)
👥 Multiple Badge Types - Total members, human-only, or bot-only counts
🛡️ Safe & Secure - Uses Discord API's with_counts=true for public access
⚡ Serverless Ready - Deploy to Vercel, Railway, Render, or any platform
🎨 Fully Customizable - Custom colors, labels, and scaling options
📱 Mobile Responsive - Optimized playground interface for all devices
📦 Zero Config - Just add your bot and start using

🎬 Project Showcase

Preview	Description
	🎬 YouTube Demo Click the image to watch the full demo.
	📝 Blog Post Read the blog for in-depth explanation.

🚀 Quick Start

1. Add Bot to Your Server

First, invite our bot to your Discord server:

🤖 Add Bot to Server

2. Enable Server Widget

Go to…

View on GitHub

Wait, wait, wait! Did you just ask for a Video Explanation? I have it for you already. Check it out here:

[ ] PROMOTION:

For the default badges on the website and the readme, I have used LLMWare's Discord Server with their consent. If you don't know, llmware just launched "Model HQ: Your Private AI Companion". The interesting part is that it runs locally and without internet.

Want to know more about it? Read it here

Rohan Sharma for LLMWare

Jun 27 '25

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

#showdev #ai #security #nocode

Comments 17

5 min read

Conclusion

In short, try this once and let me know your feedback. I don't usually say it, but save this blog for the future and star the GitHub Repository.

All links in one place:

Discord Live Members Count Website
Documentation
GitHub Repository (star it 🌠)
Video Explanation (like and subscribe)

If you want me to RAISE A PR for this badge on your GitHub repository, then let me know in the comment section.

Also, in case you want to know more about me, here's my Portfolio (and yeah, try to find out the secret page, it's still waiting for you.)

Thanks for reading till here. You're awesomeeeeeeeeeee. Here's a hug from me 🫂. Keep growing. You're the best. 🫀

How to Run AI Models Privately on Your AI PC with Model HQ; No Cloud, No Code

Rohan Sharma — Fri, 27 Jun 2025 04:20:58 +0000

In an era where efficiency and data privacy are paramount, Model HQ by LLMWare emerges as a game-changer for professionals and enthusiasts alike. Built by LLMWare, Model HQ is a groundbreaking desktop application that transforms your own PC or laptop into a fully private, high-performance AI workstation.

Most AI tools rely on the cloud. Model HQ doesn’t.

No more cloud latency. No more vendor lock-in. Just 100+ cutting-edge AI models, blazing fast document search, and natural language tools; all running locally on your machine.

What is Model HQ?

Model HQ is a powerful, no-code desktop application that enables users to run enterprise-grade AI workflows locally, securely, and at scale, right from their own PC or laptop. Designed for simplicity and performance, it provides point-and-click access to 100+ state-of-the-art AI models, ranging from 1B to 32B parameters, with built-in optimization for AI PCs and Intel hardware. Whether you’re building AI applications, analyzing documents, or querying data, Model HQ automatically adapts to your device’s specs to ensure fast, efficient inferencing, even for large models that traditionally struggle on standard formats.

What truly sets Model HQ apart is its privacy-first, offline capability. Once models are downloaded, they can be used without Wi-Fi, keeping your data and sensitive information 100% on-device. This makes it the fastest and most secure way to explore and deploy powerful AI tools without depending on the cloud or external APIs. From developers and researchers to enterprise teams, Model HQ delivers a seamless, cost-effective, and private AI experience; all in one sleek, local platform.

What Model HQ can do?

1. Chat:
The Chat feature allows users a fast way to start experimenting with chat models of various sizes, from Small (1–3 billion parameters), Medium (7–8 billion parameters) to Large (9 and above, up to 32 billion parameters).

Small Model:

~1–3 billion parameters — Fastest response time, suitable for basic chat.
Medium Model:

~7–8 billion parameters — Balanced performance, ideal for chat, data analysis and standard RAG tasks.
Large Model:

~9 up to 32 billion parameters — Most powerful chat, RAG, and best for advanced and complex analytical workloads.

Watch Chat in Action

2. Agents
Agents in Model HQ are pre-configured or custom-built workflows that automate complex tasks using local AI models. They allow users to process files, extract insights, or perform multi-step operations; all with point-and-click simplicity and no coding required.

Users can build new agents from scratch, load existing ones (either from built-in templates or previously created workflows), and manage them through a simple dropdown interface. From editing or deleting agents to running batch operations on multiple documents, the Agent system provides a flexible way to scale private, on-device AI workflows. Pre-created agents include powerful tools like Contract Analyzer, Customer Support Bot, Financial Data Extractor, Image Tagger, and more — each designed to handle specific tasks efficiently.

Watch Agents in Action

3. Bots
The Bots feature allows users to create their own custom Chat and RAG bots seamlessly for either the AI PC/edge device use case (Fast Start Chatbot and Model HQ Biz Bot) or via API deployment (Model HQ API Server Biz Bot).

Watch Bots in Action

4. RAG
RAG combines retrieval-based techniques with generative AI to allow models to answer questions more accurately by retrieving relevant information from external sources or documents. With RAG in Model HQ, you can create knowledge bases that you can query in the chat section or via a custom bot by uploading documents. The RAG section is used only to create the knowledge base.

Watch Rag in Action

5. Models
The Models section allows you to explore, manage, and test models within Model HQ. You can discover new models, manage downloaded models, review inference history, and run benchmark tests; all from a single interface.

And this all can be done, while keeping your data private, your workflows offline, and your AI performance fully optimized for your device — no internet, no cloud, and no compromise. With its powerful features and user-friendly interface, Model HQ empowers you to leverage AI technology without compromising on security. Experience the future of AI today and transform the way you work!

System Requirements

Experience Model HQ Risk-Free

We understand that trying new software can be a leap of faith. That’s why we’re offering a 90-day free trial for developers. Experience the full capabilities of Model HQ without any commitment. Sign up for the trial here and discover how it can transform your workflow.

A Powerful Collaboration with Intel

LLMWare.ai has partnered with Intel to optimize Model HQ for peak performance on your devices. This collaboration ensures that you receive a reliable and efficient AI experience, making your tasks smoother and more productive. Learn more about this exciting partnership here.

Read the Intel Solution Brief here:

Local AI—No Code, More Secure with AI PCs and the Private Cloud

Bring secure, no-code GenAI to your enterprise with Intel® AI PCs and LLMWare’s Model HQ—run agents and RAG queries locally without exposing data or incurring cloud costs. In this brief, learn how to scale private AI simply and affordably.

intel.com

Take the Next Step Towards AI Empowerment

Don’t miss the chance to elevate your productivity with Model HQ. Whether you’re a business professional, a developer, or a student, this application is designed to meet your needs and exceed your expectations.

Purchase Model HQ Today!

Ready to unlock the full potential of AI on your PC or laptop? Buy Model HQ now by clicking here and take the first step towards a smarter, more efficient future.

Learn More About Model HQ

For additional information about Model HQ, including detailed features and user guides, visit our website. Don’t forget to check out our introductory video and explore our YouTube playlist for tutorials and tips.

Join the LLMWare’s official Discord Server to interact with LLMWare's great community of users and if you have any questions or feedback.

Conclusion

Model HQ isn’t just another AI app, it’s a complete, offline-first platform built for speed, privacy, and control. Whether you’re chatting with LLMs, building agents, analyzing documents, or deploying custom bots, everything runs securely on your own PC or laptop. With support for models up to 32B parameters, RAG-enabled document search, natural language SQL, and no-code workflows, Model HQ brings enterprise-grade AI directly to your desktop, no cloud required.

As the world moves toward AI-powered productivity, Model HQ ensures you’re ahead of the curve with a faster, safer, and smarter way to work.

Creating a Chatbot from Scratch and Vibe Coding the UI💃

Rohan Sharma — Sat, 21 Jun 2025 08:27:35 +0000

Hey all,

I hope you remember me. (Yes?? LMK in the comment section.)

In this blog, I will discuss Radhika: Adaptive Reasoning & Intelligence Assistant. It provides specialized assistance across six distinct modes: General, Productivity, Wellness, Learning, Creative, and BFF.

Radhika

Radhika is a versatile AI chatbot designed to assist with a wide range of tasks, from answering questions to providing recommendations and engaging in casual conversation.

radhika-sharma.vercel.app

(try it out, give feedback and suggestions, request changes)

🛠️ Tech Stack

Frontend

Framework: Next.js 14 with App Router and React 18
Styling: Tailwind CSS with custom design system
Components: shadcn/ui component library
Icons: Lucide React icon library
3D Graphics: Three.js for particle visualizations
Animations: CSS transitions and keyframe animations

AI & Backend

AI Integration: Vercel AI SDK for unified LLM access
Providers: Groq, Google Gemini, OpenAI, Claude
Speech: WebKit Speech Recognition and Synthesis APIs
Storage: Browser localStorage for chat persistence and settings
API: Next.js API routes for secure LLM communication

Development

Language: TypeScript for type safety
Build: Next.js build system with optimizations
Deployment: Vercel-ready with environment variable support
Performance: Optimized bundle splitting and lazy loading

🚀 Implementing Main Logic

This section breaks down how the app/api/chat/route.ts endpoint processes requests, selects models, applies system prompts, and streams responses using different AI providers.

1. Parse Request

The request handler begins by parsing the JSON body from the incoming POST request:

const body = await req.json();
const { messages, mode = "general", provider = "groq", apiKey } = body;

messages: The conversation history sent by the client.
mode: Determines which system prompt to use (e.g., bff, learning, etc.).
provider: Specifies the AI backend to use (groq, openai, claude, gemini).
apiKey: Required for OpenAI and Claude if a user key is needed.

The code also validates whether the messages array exists and is non-empty.

2. Assign System Prompt

Based on the selected mode, a system prompt is selected to guide the assistant's personality and purpose:

const systemPrompt = SYSTEM_PROMPTS[mode] || SYSTEM_PROMPTS.general;

Examples of modes include:

productivity
bff
creative
wellness

3. Route to the Correct Provider

The provider field determines which AI model backend to use:

Gemini (google): Uses Google's Gemini 2.0 model.
OpenAI: Uses GPT models (like gpt-4o, gpt-3.5-turbo).
Claude: Uses Anthropic models (like claude-3-sonnet).
Groq: Defaults to models like llama-3 and qwen.

Each provider has custom logic to instantiate the model, handle errors, and stream the response using:

await streamText({...})

4. Model Selection (Groq Only)

If the provider is groq, model selection is dynamic. It analyzes the last message to determine the type of task:

if (lastMessage.includes("analyze") || lastMessage.includes("plan")) {
  modelType = "reasoning";
} else if (lastMessage.includes("creative") || lastMessage.includes("design")) {
  modelType = "creative";
} else {
  modelType = "fast";
}

RADHIKA automatically selects the best model based on your query complexity:

// Determine which model to use based on conversation context
let modelType = "fast"; // llama-3.1-8b-instant for quick responses

// Use reasoning model for complex analytical tasks
if (query.includes("analyze", "compare", "plan", "strategy", "decision", "problem")) {
  modelType = "reasoning"; // llama-3.3-70b-versatile
}

// Use creative model for artistic and innovative tasks
if (query.includes("creative", "brainstorm", "idea", "write", "design", "story")) {
  modelType = "creative"; // qwen/qwen3-32b
}

Model Configuration

Customize model selection in the API route:

const MODELS = {
  groq: {
    fast: "llama-3.1-8b-instant",
    reasoning: "llama-3.3-70b-versatile", 
    creative: "qwen/qwen3-32b"
  },
  gemini: { default: "gemini-2.0-flash" },
  openai: { default: "gpt-4o" },
  claude: { default: "claude-3-5-sonnet-20241022" }
}

Then the appropriate model (reasoning, creative, or fast) is selected and used for the response.

📄 Multi-Provider Flow

This approach allows a single API route to serve multiple model providers and assistant personalities while maintaining clean, scalable logic.

If you're interested in knowing about the other logics like voice recognition and speech synthesis, light/dark mode, etc,. then please go over the github repo:

RS-labhub / Radhika

Radhika is a multi-model AI assistant built for your mood and friendship 💞

Radhika

Try now: https://radhika-sharma.vercel.app

Detailed Explanation

Preview	Description
	Blog Post Read the blog for in-depth explanation.
	YouTube Demo Coming soon.

Features

6 Chat Modes: General, Productivity, Wellness, Learning, Creative, BFF
Multi-Provider LLM: Groq, Gemini, OpenAI, Claude
Image Generation: Pollinations, DALL·E 3, Hugging Face, Free alternatives
Voice: Speech-to-text input & text-to-speech output
Auth & Persistence: Appwrite auth with chat history & favorites
UI: Light/dark themes, modern & pixel UI styles

Quick Start

git clone https://github.com/RS-labhub/radhika.git
cd radhika
bun install   # or npm install
bun run dev   # or npm run dev

Open: http://localhost:3000

License

MIT License - see LICENSE

Built with ❤️ by Rohan Sharma

⭐ Star • 🐛 Issues • 🗣️…

View on GitHub

Vibe Coding the UI

When you have successfully implemented the main logic of your application, use the AI tools like v0, lovable, or bolt to create an interface according to your "thoughts".

I used v0 and ChatGPT. Prompting... Prompting... and never-ending prompting... Check out the video below to see a simple, short explanation of this project with features. However, you still have live access to it!

If you like it, then please star the repo 🌠 and follow me on GH.

Key Highlights

🤖 Multi-Modal AI - Six specialized assistant personalities in one app
⚡ Multi-Provider Support - Groq, Gemini, OpenAI, and Claude integration
🎤 Advanced Voice - Speech-to-text input and text-to-speech output
🎨 Dynamic 3D Visuals - Interactive particle system with mode-based colors
💾 Smart Persistence - Automatic chat history saving per mode
🚀 Quick Actions - One-click access to common tasks per mode
📊 Real-time Analytics - Live usage statistics and AI activity monitoring
🌙 Beautiful UI - Responsive design with dark/light themes

Modes

Productivity: Task planning, project management, time optimization
Wellness: Health guidance, fitness routines, mental well-being support
Learning: Educational assistance, study plans, skill development
Creative: Brainstorming, content creation, artistic inspiration
General: Problem-solving, decision-making, everyday conversations
BFF: Emotional support, casual chats, GenZ-friendly interactions

Perfect for users who need a versatile AI assistant that adapts to different contexts, maintains conversation history across specialized domains, and provides an engaging visual experience with advanced voice capabilities.

Conclusion

Radhika is a sophisticated AI-powered assistant built with Next.js and powered by multiple LLM providers including Groq, Gemini, OpenAI, and Claude. RADHIKA adapts to different modes of interaction, providing specialized assistance for productivity, wellness, learning, creative tasks, and even acts as your GenZ bestie!

I personally suggest you try the "BFF" mode. You will like it for sure.

Once again, here are the links you don't want to miss out:

Live Demo: https://radhika-sharma.vercel.app/ (added modern/pixel UI options)
Github Repo: https://github.com/RS-labhub/Radhika (Give it a star 🌠)
Youtube Demo: https://www.youtube.com/watch?v=2FW6IJeOkzI

Thank you for reading. You're wonderful. And I mean it. Ba-bye, see you in the next blog. (and PLEASE SPAM THE COMMENT SECTION AS ALWAYS)

Find My Portfolio’s Secret Page; If You Can 🤫

Rohan Sharma — Fri, 13 Jun 2025 11:15:03 +0000

Did you miss me? I guess, yeah, you did. Sorry for that. I was so busy with my DevRel work at llmware. (not flaunting)

Btw, finally I'm able to complete my portfolio website. And this is what I wanted to share with my dev.to fam.

Thanks to AI tools that accelerated the process. Vibe coding is not that bad; it saves a lot of time.

So, let's start this super mini blog.

3... 2... 1... 🟢

Welcome to `RS PORTFOLIO` 👋

First of all, don't expect too much. It's just a normal portfolio. IS IT? Who knows.

Before discussing more about it, let me tell you the tech stack I have used:

NextJs (frontend and backend)
Radix UI (UI Enhancements)
FormSpree (for creating free unlimited forms)
Vercel (hosting)

And boom! These resources were enough to create a good-looking portfolio. Actually, my portfolio DP is the main reason for the clean UI. 🙂 (please say "yes")

Btw, it's responsive also. BUT I SUGGEST YOU TAKE A LOOK AT A BIGGER SCREEN. Mobile view is not that great. (Of course, I'm NOT going to work on this again)

Rohan Sharma - Software Developer, Professional Blog Writer and UI/UX Designer

Explore the portfolio of Rohan Sharma, featuring cutting-edge software projects, insightful blogs, and creative UI/UX work.

rohansrma.vercel.app

What makes my PORTFOLIO UNIQUE?

Simple and Professional UI?
Easy navigation?
Adding "not available for work" label in the experience page?
Printing Resume?
SECRET BUTTON?

Every portfolio is unique, and I can't judge them. (btw, I always judge them, an in-built feature)

My portfolio is also like other portfolio/. You can judge it as well. I tried to WRITE AS MANY FAKE THINGS AND SHOWCASE FAKE EXPERTISE AS POSSIBLE. What do you mean, everyone does it? 😂

I don't want to emphasize more on the SECRET BUTTON. Because it is very unprofessional. But those who know me personally must have expected something like this from me. So, I have to stand on their beliefs.

I, particularly, WANT YOU TO TAKE A LOOK AT MY PORTFOLIO, EXPLORE EVERY SECTION, AND GIVE ME FEEDBACK. (Feedback is important, you know. Doesn't matter whether I will implement them or not. Even if I'm implementing then, I can't say about the timespan. It may take decades.)

If you're a dark mode lover, I have added a dark mode functionality. TOTALLY AI DEPENDENT to implement this feature. I don't want to spend much time on color change.

I mostly used chatGPT for bug fixes (those F*** hydration errors) and v0 to amplify building and improved UI/.

The Mystery of SECRET BUTTON

Again, before starting, I want to say, "Please don't go for it. It's just a random off-topic, unprofessional button, and made for fun".

The secret button, as the name suggests, is very secret and so hidden. There's only one point to access that button. Yes, A SINGLE POINT.

It can be present anywhere and in any section. If you want to see it, then you have to FIND IT BY YOURSELF.

The secret page consists of nothing but my personal space, where I'm trying to change my relationship status from SINGLE TO BEING MINGLE. It's boring as there are long essays and boring paragraphs. NOT DEVELOPER FRIENDLY.

A little glance of the secret page:

What?? C'mon, I already told "A LITTLE".

Jokes Apart, Time to Conclude

Sorry for a short and promotional blog. I just wanted to share this with you guys.

Upcoming blog, going to be very cool. And you'll like it for sure!

Sharing again the Portfolio link: https://rohan-sharma-portfolio.vercel.app/

If you liked my portfolio, then comment.
If you found any bugs, then comment.
If you have any feedback, then comment.
If you want me to build an MCP (of your choice), then comment.

Thanks for reading and your support. You're the best. Keep loving me!

Access Granted!! Here's the recipe behind my AI DMS 🤞

Rohan Sharma — Sun, 04 May 2025 08:23:49 +0000

This is a submission for the Permit.io Authorization Challenge: AI Access Control

Hey there,
Welcome back! This is my 2nd entry for the Permit.io Authorization Challenge. (If you want to see the 1st one, here's the link: https://dev.to/rohan_sharma/access-control-handled-heres-how-i-built-my-dms-212)

This project is not different than the last one. It's still a document management system, but it now has more powerful features and configurations.//..

Welcome to Radhika's AI DocManager

Radhika's AI DocManager is still a DMS, but now it's come with the power of AI, new settings and configurations, modern UI (best dark mode), and powerful features. Test it on your local machine now!!! 👾

This project demonstrates how to implement fine-grained authorization for both users and AI agents in a Next.js application using Permit.io. It's a document management system where users can create, view, edit, and delete documents based on their roles and document ownership, and AI agents can assist with document management based on their assigned permissions.

Features

1️⃣ User Authorization

Role-Based Access Control (RBAC): Different roles (Admin, Editor, Viewer) have different permissions
Attribute-Based Access Control (ABAC): Document owners have special privileges
Fine-Grained Authorization: Using Permit.io to implement complex authorization rules

2️⃣ AI Authorization

AI Agent Roles: Define different AI agent roles with specific capabilities
Permission Levels: Configure what AI agents can access and modify
- No Access: AI agent cannot access the resource at all
- Read Only: AI agent can only read but not modify resources
- Suggest Only: AI can suggest changes that require human approval
- Full Access: AI has full access to read and modify resources
Approval Workflows: Require human approval for sensitive AI operations
Audit and Monitoring: Track all AI actions and approvals

3️⃣ Document Intelligence

Document Analysis: AI-powered analysis of document content and structure
Document Summarization: Generate concise summaries of documents
Content Improvement: AI suggestions for improving document content

Demo

Project Repo

Github Repo: https://github.com/RS-labhub/AI-DocManager

Documentation: https://rs-labhub.github.io/AI-DocManager/

My Journey

As said in the last blog, it was quite difficult to create a DMS or document management system, as there are so many brainstorming behind this.

Anyway, thanks to Permit.io for saving a lot of my time while creating policies. It's easy to use and enough to say goodbye to the old methods where we die while writing the code.

I used Permit.io to achieve these things:

Role-Based Access Control or RBAC
Attribute-Based Access Control or ABAC

Also, implemented the roles the AI should have. Here's both RBAC and ABAC are used. I used GROQ Cloud for fast LLM inference and OpenAI compatibility.

Overall, it was a fun experience building this project, and I enjoyed building it.

If you want to see the whole implementation of the Permit.io, please read the project Readme file!

Authorization for AI Applications with Permit.io

Authorization Model

User Authorization

The application implements the following user authorization model:

Admin: Can create, view, edit, and delete any document, and access the admin panel
Editor: Can create, view, and edit documents, but can only delete their own documents
Viewer: Can only view documents

Additionally, document owners have full control over their own documents regardless of their role.

AI Authorization

The application implements the following AI authorization model:

AI Agent Roles:
- Assistant: Helps with document organization and basic tasks
- Editor: Can edit and improve document content
- Analyzer: Analyzes document content and provides insights
AI Capabilities:
- read_documents: Ability to read document content
- suggest_edits: Ability to suggest edits to documents
- edit_documents: Ability to directly edit documents
- create_documents: Ability to create new documents
- delete_documents: Ability to delete documents
- analyze_content: Ability to analyze document content
- summarize_content: Ability to summarize documents
- translate_content: Ability to translate documents
- generate_content: Ability to generate new content
Permission Levels:
- NO_ACCESS: AI agent cannot access the resource at all
- READ_ONLY: AI agent can only read but not modify resources
- SUGGEST_ONLY: AI can suggest changes that require human approval
- FULL_ACCESS: AI has full access to read and modify resources

Implementation Details

AI Authorization Implementation

The application implements AI authorization through several key components:

1. AI Agent Management

The AIAgent interface defines the structure of AI agents:

export interface AIAgent {
  id: string;
  name: string;
  description: string;
  role: AIAgentRole;
  capabilities: AICapability[];
  createdBy: string;
  createdAt: string;
  updatedAt: string;
  isActive: boolean;
}

Administrators can manage AI agents through the admin panel, defining their roles and capabilities.

2. Permission Levels

The AIPermissionLevel enum defines the different levels of access that AI agents can have:

export enum AIPermissionLevel {
  NO_ACCESS = "no_access",
  READ_ONLY = "read_only",
  SUGGEST_ONLY = "suggest_only",
  FULL_ACCESS = "full_access",
}

3. AI Actions

The AIAction interface defines the structure of actions that AI agents can perform:

export interface AIAction {
  id: string;
  agentId: string;
  actionType: string;
  resourceType: string;
  resourceId: string;
  status: AIActionStatus;
  requestedAt: string;
  completedAt?: string;
  requestedBy: string;
  approvedBy?: string;
  rejectedBy?: string;
  metadata: Record<string, any>;
  result?: any;
}

4. Permission Checking

The checkAIPermission function checks if an AI agent has permission to perform an action:

export function checkAIPermission(
  agentId: string,
  action: string,
  resourceType: string,
  resourceId?: string
): {
  permitted: boolean;
  requiresApproval: boolean;
  permissionLevel: AIPermissionLevel;
} {
  // Implementation details...
}

5. Approval Workflow

The application implements an approval workflow for AI actions that require human oversight:

export async function requestAIAction(
  agentId: string,
  actionType: string,
  resourceType: string,
  resourceId: string,
  documentTitle: string,
  documentContent: string,
  metadata: Record<string, any>
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

export async function approveAIAction(
  actionId: string,
  userId: string
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

export async function rejectAIAction(
  actionId: string,
  userId: string,
  reason?: string
): Promise<{ success: boolean; action?: AIAction; message?: string }> {
  // Implementation details...
}

Integration with Permit.io

The application integrates with Permit.io through the permit.ts file, which provides functions for checking permissions:

import { Permit } from 'permitio';

// Initialize Permit SDK
const permit = new Permit({
  pdp: process.env.PERMIT_PDP_URL,
  token: process.env.PERMIT_SDK_TOKEN,
});

// Check if a user can perform an action on a resource
export async function checkPermission(
  userId: string,
  action: string,
  resourceType: string,
  resourceAttributes: Record<string, any> = {}
): Promise<boolean> {
  try {
    const permitted = await permit.check(userId, action, {
      type: resourceType,
      ...resourceAttributes,
    });
    return permitted;
  } catch (error) {
    console.error('Permission check failed:', error);
    return false;
  }
}

Conclusion

This project demonstrates how to implement fine-grained authorization for both users and AI agents in a Next.js application using Permit.io. By externalizing authorization, we can create more secure, maintainable, and flexible applications that can safely leverage AI capabilities while maintaining appropriate controls.

Please try to run it locally on your machine and let me know the feedback!

Thank you for taking your time to read this blog. I hope you enjoyed it. Your support means the world to me. Thank youuuuuuuuuuuuuuuuu! ❣️

Access Control? Handled. Here's How I Built My DMS 🌠

Rohan Sharma — Tue, 29 Apr 2025 19:08:04 +0000

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

What I Built

Hi there! 👋
Presenting to you "Radhika's DocManager": A secure Document Management System (or DMS) with fine-grained authorization powered by Permit.io.

This is the first version of Radhika's DocManager, which allows you to create, read, write, and delete documents based on their role and document ownership.

Features

Role-Based Access Control (RBAC): Different roles (Admin, Editor, Viewer) have different permissions
Attribute-Based Access Control (ABAC): Document owners have special privileges
Fine-Grained Authorization: Using Permit.io to implement complex authorization rules
Next.js App Router: Modern React application with server components and server actions
Responsive UI: Using Tailwind CSS and shadcn/ui components

Authorization Model

The application implements the following authorization model:

Admin: Can create, view, edit, and delete any document, and access the admin panel
Editor: Can create, view, and edit documents, but can also delete their own documents
Viewer: Can only view documents

Additionally, document owners have full control over their own documents regardless of their role.

Demo

Project Repo

https://github.com/RS-labhub/Document_Management_System

My Journey

Creating a DMS was a very hectic job, especially while writing the access control. Thanks to Permit, which makes it easier and serves as a super time saver.

The thing that focused more on this application is the "Use of Permit". This also proves how a simple application becomes so powerful by adding access controls.

Anyway, the project is open-source. If you want to contribute, you're warmly welcome.

Using Permit.io for Authorization

I used Permit to achieve two things:

Role-Based Access Control or RBAC
Attribute-Based Access Control or ABAC

In the RBAC policy, 3 roles are created: Admin, Editor, and Viewer. The properties/permissions of each role are mentioned in the image.

In the ABAC policy, access is determined by document attributes and user context.

If you want to see the whole implementation of the Permit, please read the project Readme file!

Conclusion

A huge thanks to @jennie_py for their contribution to this project!

This project demonstrates how to implement fine-grained authorization in a Next.js application using Permit.io. By externalizing authorization, we can create more secure, maintainable, and flexible applications.

Thank you for reading this so far! Your support means the world to us. ❣️