DEV Community: Maneesh Thakur

RepoReady — Instant AI-powered onboarding for any GitHub, GitLab, or Bitbucket repo

Maneesh Thakur — Sun, 01 Mar 2026 19:52:12 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

Every developer has felt it: you click a link to a new repository, the file tree opens, and you just... stare. Where do you start? What even is this thing?

The open source contributor community has a deeply broken onboarding experience. READMEs are outdated within months of being written. Architecture docs don't exist. Setup instructions assume you already know the stack. First-time contributors give up before they ever submit a PR.

I've been there. You've been there. Every developer you know has been there.

This project is for that community — for every dev who has ever opened a codebase and immediately felt lost.

What I Built

RepoReady — paste any public (or private) repo URL → get a structured AI-generated onboarding guide in seconds.

No installation. No backend. No data stored. Just open the page and go.

The guide covers five sections automatically extracted from the repo:

💡 What the project does — plain English, no jargon
🧩 Tech stack — every language, framework, and dependency explained
🗂️ Folder structure — what each directory is actually for
🚀 How to get started — setup steps pulled straight from the code
🏁 Where to contribute — suggested entry points for first-timers

After analysis, you can:

⬇ Export as Markdown — download a clean .md file, commit it alongside your codebase
🔗 Share — copy a URL pre-filled with the repo to send teammates

Demo

https://maneesh-relanto.github.io/DevTo-CommunityChallenge-RepoReady/

(https://maneesh-relanto.github.io/DevTo-CommunityChallenge-RepoReady/)

Code

[https://github.com/Maneesh-Relanto/DevTo-CommunityChallenge-RepoReady

How I Built It

Architecture: zero-backend, client-side only

The entire app is a static HTML/CSS/JS project. No server, no API keys stored server-side, no database. Everything runs in the browser.

User Input (Repo URL + AI API Key)
        │
        ▼
┌──────────────────────────────┐
│  Detect platform from URL    │
│  github.com / gitlab.com /   │
│  bitbucket.org               │
└──────────────────────────────┘
        │
        ▼
┌──────────────────────────────┐
│  Platform API call           │
│  • Repo metadata             │
│  • README (first 4000 chars) │
│  • File tree (up to 120)     │
│  • Package manifest          │
│    (package.json / Cargo.toml│
│     / pyproject.toml / etc.) │
└──────────────────────────────┘
        │
        ▼
┌──────────────────────────────┐
│  Structured prompt → AI      │
│  Returns JSON with 5 keys    │
└──────────────────────────────┘
        │
        ▼
┌──────────────────────────────┐
│  Render onboarding guide     │
│  + Markdown export           │
│  + Shareable link            │
└──────────────────────────────┘

File structure

repoready/
├── index.html      # HTML shell + layout
├── package.json    # ESM declaration + npm test script
├── css/
│   └── styles.css  # Design tokens, animations
├── js/
│   ├── app.js      # Main entry — wires everything
│   ├── ai.js       # All 7 AI provider adapters
│   ├── git.js      # GitHub, GitLab, Bitbucket fetchers
│   ├── ui.js       # DOM rendering, export, history
│   └── config.js   # Centralised constants
├── tests/
│   ├── git.test.js     # 17 unit tests
│   ├── ai.test.js      # 16 unit tests
│   └── history.test.js # 12 unit tests
└── README.md

Multi-provider AI

Seven providers, switchable at runtime — user brings their own key (Ollama is fully local, no key needed):

Provider	Models
Claude (Anthropic)	claude-sonnet-4-6, claude-opus-4-6, claude-haiku-4-5
OpenAI	gpt-4o, gpt-4o-mini, gpt-4-turbo
Google Gemini	gemini-2.0-flash, gemini-2.0-flash-lite, gemini-1.5-pro
Mistral AI	mistral-large-latest, mistral-small-latest, codestral-latest
xAI Grok	grok-3, grok-3-fast, grok-2-1212
Groq 🆓	llama-3.3-70b-versatile, llama-3.1-8b-instant, mixtral-8x7b
Ollama 🏠	llama3.2, mistral, codellama, phi4 (runs locally)

Multi-platform Git support

GitHub uses the REST API (/repos/{owner}/{repo}/git/trees/HEAD?recursive=1) to get the full recursive file tree in a single call.

GitLab uses the projects API + a separate /languages endpoint to correctly identify the primary language (GitLab doesn't expose this in the main project object).

Bitbucket required extra work — its /src endpoint is not recursive, so I fetch the root directory and then fan out parallel requests for each first-level subdirectory to build a meaningful tree.

Prompt engineering

The prompt is structured to return strict JSON — no markdown fences, no free text — which makes parsing reliable across all three AI providers. I specifically extract and inject the package manifest (e.g. package.json, Cargo.toml, pyproject.toml) into the prompt so the AI has concrete dependency information rather than guessing from filenames.

Challenges

ES modules over file://
The project uses native ES modules, which browsers block when opened directly from the filesystem (CORS restriction). This bit me during early testing — index.html opened from a double-click was completely silent. The fix is trivial (python -m http.server), but catching it and documenting it clearly matters for contributors.

Bitbucket's flat file tree
Unlike GitHub and GitLab, Bitbucket's /src endpoint returns only the immediate directory listing rather than a recursive tree. I worked around this by fanning out parallel requests to each root-level subdirectory — capped at 20 concurrent requests to stay polite — which gives a meaningful two-level tree in most cases.

AI response consistency
Three different AI providers all produce slightly different formatting, even when instructed to return raw JSON. The parser uses a greedy /{[\s\S]*}/ regex to extract the first complete JSON object from the response, which handles models that wrap JSON in markdown code fences despite explicit instructions not to.

Keeping it zero-dependency
The temptation to reach for a markdown renderer, a UI library, or a bundler is real. I deliberately resisted — the whole project loads from a single <script type="module"> tag. No npm install, no build step, no node_modules. This constraint forced cleaner separation of concerns and makes the project trivially deployable to any static host.

Try It Yourself

Open https://maneesh-relanto.github.io/DevTo-CommunityChallenge-RepoReady/
Pick an AI provider, paste your API key
Enter any repo URL — try one of these to start:
- https://github.com/expressjs/express
- https://github.com/django/django
- https://github.com/rust-lang/rust
Click Analyze →

Source: https://github.com/Maneesh-Relanto/repoready

LearnHub - A Community-First Learning Platform

Maneesh Thakur — Sun, 01 Mar 2026 14:01:03 +0000

This is a submission for the DEV Weekend Challenge: Community

The Community

LearnHub was built for learning communities - the study groups, coding circles, book clubs, bootcamp cohorts, and open-source learning teams that power collaborative education.

These communities face real coordination challenges:

📚 Resource Chaos: Great materials get lost in Slack/Discord messages
🔍 No Discovery: Hard to find quality resources shared by peers
📊 No Visibility: Nobody knows what's been shared, who contributed, or how valuable materials are
⏰ No Structure: Difficult to coordinate learning progression or paths

LearnHub solves these problems by creating a centralized hub where learning communities can organize, discover, and collaborate around shared resources.

What I Built

LearnHub is a modern, community-first learning platform with:

📚 Core Features

✨ Resource Library - Central repository for course materials, links, documents, videos, and code

Add resources with rich metadata (type, tags, difficulty, time estimate)
Pin important resources to highlight them
Full-text search with multi-criteria filtering
Share resources in multiple formats (Plain Text, Markdown, JSON)

⭐ Resource Ratings - Community-driven quality assessment

Rate resources 1-5 stars with optional reviews
See average ratings and member feedback
Build trust through peer validation
Identify high-value materials at a glance

🎯 Learning Paths - Structured learning sequences

Create ordered paths through resources
Set difficulty levels and time estimates
Visualize learning progression
Share curated learning sequences with groups

👤 User Profiles - Showcase member contributions

Public profiles with member stats
Track resources contributed, average ratings, groups joined
Edit profile with custom bio and avatar
See all member contributions at a glance

🌙 Dark Mode - Beautiful theme support

Toggle between light and dark modes
Persistent theme preference
System preference detection
Seamless across all pages

🏠 Group Management

Browse and search learning groups by topic
Create new groups instantly
Join/leave groups with one click
View group members and resources

🎨 Design Excellence

Clean, modern UI with Tailwind CSS
Responsive design (mobile-first)
Smooth animations and transitions
Accessibility-first (WCAG AA+)
Dark mode support
Compact, focused layout

Demo

Live Demo: LearnHub on Cloudflare Pages

Quick Demo Flow:

Homepage - See platform overview with stats
Browse Groups - Explore learning communities by topic
Join a Group - Click any group to join instantly
Explore Resources - View, search, and filter group resources
Add Resources - Share a new resource with your group
Rate Resources - Give feedback with ratings and reviews
View Profile - See your contributions and stats
Create Learning Path - Build a structured learning sequence
Toggle Dark Mode - Try light/dark theme switching

Key Pages:

/ - Homepage with featured groups and stats
/groups - Browse all learning groups
/groups/[id] - Group detail page with resource library
/paths - Learning paths browsing and creation
/profile - User profile with contributions
/about - About LearnHub

Code

GitHub Repository: Maneesh-Relanto/DevTo-CommunityChallenge-LearnHub

LearnHub/
├── client/
│   ├── pages/
│   │   ├── Index.tsx              # Homepage
│   │   ├── GroupsDirectory.tsx    # Browse groups
│   │   ├── GroupDetail.tsx        # Group & resources
│   │   ├── LearningPaths.tsx      # Learning paths
│   │   ├── UserProfile.tsx        # User profiles
│   │   └── About.tsx              # About page
│   ├── components/
│   │   ├── groups/                # Group components
│   │   ├── resources/             # Resource components
│   │   ├── paths/                 # Learning path components
│   │   ├── user/                  # User/profile components
│   │   └── ui/                    # UI primitives
│   ├── context/
│   │   ├── UserContext.tsx        # User state management
│   │   ├── GroupContext.tsx       # Groups state management
│   │   ├── ResourceContext.tsx    # Resources state management
│   │   ├── PathContext.tsx        # Learning paths state
│   │   └── ThemeContext.tsx       # Dark mode state
│   ├── types/
│   │   └── index.ts               # TypeScript interfaces
│   └── App.tsx                    # Main app component
├── package.json
├── vite.config.ts
├── tsconfig.json
└── README.md

Key Stats:

📦 Codebase: ~2,500 lines of TypeScript/React
🎨 Components: 20+ reusable components
🗄️ State Management: 5 Context providers
✅ Tests: 92% passing (48/52 unit tests)
🚀 Build Size: 796 KB (gzipped: 215 KB)
⚡ Performance: No console warnings, optimized renders

How I Built It

🛠️ Technology Stack

Frontend Framework

React 18.3 - Modern UI library with hooks
TypeScript 5.9 - Type-safe development
Vite 7 - Lightning-fast build tool
React Router 6 - Client-side routing (SPA)

Styling & UI

Tailwind CSS 3.4 - Utility-first styling
Radix UI - Accessible component primitives
Lucide React - Beautiful icon library
Custom CSS animations - Smooth transitions

State Management

React Context API - Global state management
Custom hooks - Reusable logic
localStorage - Client-side persistence

Testing & Quality

Vitest 3.2 - Fast unit test framework
React Testing Library - Component testing
TypeScript Strict Mode - Type safety
ESLint & Prettier - Code quality

Deployment

Cloudflare Pages - Static hosting
GitHub Actions - CI/CD (auto-deploy on push)
SPA routing configuration - Client-side navigation

🏗️ Architecture Decisions

Component-Driven Development

Small, focused components with single responsibility
Reusable UI components in /components/ui
Feature-specific components grouped by domain
Props-based configuration for flexibility

State Management Pattern

Context API for global state (User, Groups, Resources, Paths, Theme)
Custom hooks for easy consumption (useUser, useGroups, etc.)
localStorage for persistence across sessions
Centralized action functions for predictable updates

Type Safety

Strict TypeScript mode enabled
Interfaces for all data models
No any types in codebase
Type-safe component props

Performance Optimizations

useMemo for expensive computations (filtering, sorting)
useCallback for stable function references
Lazy routing with React.lazy (when needed)
Optimized re-renders with proper dependency arrays

Testing Strategy

Unit tests for contexts (data logic)
Hook tests with React Testing Library
Component snapshot tests
Integration tests for workflows

🎯 Key Features Implementation

Resource Ratings

// Rating interface
interface Rating {
  userId: string;
  score: number;  // 1-5
  review?: string;
  createdAt: string;
}

// Methods in ResourceContext
addRating(resourceId, userId, score, review)
getAverageRating(resourceId) -> number

Learning Paths

Ordered array of resource IDs
Difficulty level and time estimate
Creator tracking and timestamps
Visual step-by-step progression

User Profiles

Public profile pages
Contribution statistics
Editable profile info (name, bio, avatar)
Member since date tracking

Dark Mode

ThemeContext for global theme state
localStorage for persistence
System preference detection
Tailwind's dark mode utilities

📊 Data Model

// User
{
  id: string
  displayName: string
  bio?: string
  avatarUrl?: string
  joinedGroups: string[]
  createdAt: string
}

// Group
{
  id: string
  name: string
  description: string
  topic: string
  facilitator: string
  members: string[]
  resourceCount: number
  createdAt: string
}

// Resource
{
  id: string
  groupId: string
  type: 'link' | 'note' | 'document' | 'video' | 'code'
  title: string
  description: string
  tags: string[]
  difficulty: DifficultyLevel
  timeEstimate: TimeEstimate
  ratings: Rating[]
  uploadedBy: string
  isPinned: boolean
  createdAt: string
}

// Learning Path
{
  id: string
  groupId: string
  name: string
  description: string
  resourceIds: string[]
  difficulty: DifficultyLevel
  estimatedDuration: TimeEstimate
  createdBy: string
  createdAt: string
}

🚀 Development Workflow

Local Development

   pnpm install
   pnpm dev          # Start dev server with HMR
   pnpm typecheck    # Type checking
   pnpm test         # Run unit tests
   pnpm build:client # Production build

Deployment
- Push to GitHub main branch
- Cloudflare Pages auto-detects build
- Vite builds to dist/spa
- Deployed in ~2 minutes
- SPA routing via _routes.json
Code Quality
- TypeScript strict mode
- No console warnings
- Accessible components
- Responsive design
- Clean code principles

Thank You

Built with ❤️ for learning communities everywhere.

Live Demo: LearnHub
Repository: GitHub

prompt-run: Run .prompt files against any LLM from your terminal

Maneesh Thakur — Sat, 28 Feb 2026 12:01:44 +0000

The post

Prompts buried in Python strings. No git history. No way to diff two versions. No clean way to swap models.

I got tired of it. So I built prompt-run — a CLI tool that treats .prompt files as first-class runnable artifacts.

Quickstart (60 seconds)

pip install "prompt-run[anthropic]"
export ANTHROPIC_API_KEY="sk-ant-..."

prompt run examples/summarize.prompt --var text="LLMs are changing software development."

What a `.prompt` file looks like

---
name: summarize
description: Summarizes text into bullet points
model: claude-sonnet-4-6
provider: anthropic
temperature: 0.3
max_tokens: 500
vars:
  text: string
  style: string = bullets
---

Summarize the following text as {{style}}:

{{text}}

YAML frontmatter for config. Plain text body with {{variable}} syntax. That's the whole format.

The file lives in your repo. It is versioned by git. It can be reviewed in a PR. Anyone cloning your project can run it.

Commands

`prompt run` — run a prompt against any LLM

# Basic
prompt run summarize.prompt --var text="Your text here"

# Override model — no file changes needed
prompt run summarize.prompt --model gpt-4o --provider openai

# Dry run — preview the resolved prompt without sending it
prompt run summarize.prompt --var text="Hello" --dry-run

# Stream tokens as they arrive
prompt run summarize.prompt --var text="Hello" --stream

# Pipe input from stdin
cat article.txt | prompt run summarize.prompt

`prompt diff` — side-by-side output comparison

This is the feature I use most. When iterating on a prompt, you can compare two runs without leaving your terminal:

# Same prompt, two different inputs
prompt diff summarize.prompt \
  --a-var text="First article..." \
  --b-var text="Second article..."

# Two prompt versions, same input — great for regression testing
prompt diff summarize.v1.prompt summarize.v2.prompt \
  --var text="Same input for both"

`prompt validate` — catch errors before runtime

prompt validate summarize.prompt
# ✓ Valid YAML frontmatter
# ✓ All variables declared
# ✓ No undeclared variables in body

`prompt new` — scaffold a new prompt file interactively

prompt new my-prompt.prompt

Providers supported

Provider	Install extra	Auth env var
Anthropic (default)	`pip install "prompt-run[anthropic]"`	`ANTHROPIC_API_KEY`
OpenAI	`pip install "prompt-run[openai]"`	`OPENAI_API_KEY`
Ollama (local)	`pip install "prompt-run[ollama]"`	None

Switch at runtime with --provider and --model. Nothing in the .prompt file needs to change.

Use it as a Python library too

from prompt_run import run_prompt

result = run_prompt(
    "summarize.prompt",
    vars={"text": "Your text here"},
    model="gpt-4o",
    provider="openai",
)
print(result.content)

Use in CI / GitHub Actions

- name: Smoke test prompt
  run: |
    pip install "prompt-run[anthropic]"
    prompt run prompts/classify.prompt --var input="test input" --dry-run
  env:
    ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}

What this is NOT

I want to be explicit about scope:

No web dashboard
No prompt storage database
No versioning system (git handles that)
No evaluation/scoring framework
No account required
No telemetry — zero, none, nothing phones home

Why not LangChain / promptfoo / Langfuse?

These are great tools. But they all add abstraction layers and, usually, a platform or account. prompt-run is deliberately minimal — it does exactly one thing: lets you run .prompt files from the terminal. No opinions beyond that.

MD Files Connector — Stop Losing Track of Your Markdown Docs

Maneesh Thakur — Sun, 22 Feb 2026 12:00:34 +0000

The Problem

Your project has a CONTRIBUTING.md, an ARCHITECTURE.md, a docs/API.md. You wrote them. Then you forgot about them.

Nobody links to them. Nobody reads them. They just exist — invisible.

The Fix

MD Files Connector is a CLI tool + GitHub Action that scans your project for every .md file and checks which ones are actually linked from your root README.md.

Files that aren't linked? Isolated. Nobody will find them.

bash
python md_connector.py .

That's it. You get a rich terminal dashboard:

📁 Total MD files     7
✅ Linked in README   5
⚠️  Isolated           2
📊 Coverage          71.4%

And an interactive fix menu to auto-link the isolated ones into your README — no manual editing needed.

Run it in CI

Drop this into .github/workflows/md-check.yml:

`yaml
name: Run MD Files Connector
uses: Maneesh-Relanto/MD-Files-Connector@v1.0.0
with:
fail-on-isolated: "true"

Now every PR that ships an unlinked .md file fails the check. Docs stay honest automatically.

Key facts

Zero config — one Python file, one command
Language agnostic — works with any repo regardless of tech stack
Privacy first — nothing leaves your machine, no network calls
CI-friendly — --fail-on-isolated exits with code 1
Auto-fix — interactive menu patches your README for you
Open source — MIT, single readable file you can audit

Links

GitHub: https://github.com/Maneesh-Relanto/MD-Files-Connector
Marketplace: https://github.com/marketplace/actions/md-files-connector

Please share the feedback and happy to hear on the suggestions.

hosting cost - soaring

Maneesh Thakur — Sat, 14 Feb 2026 18:24:04 +0000

Why React + TypeScript Hosting is Costly ?

• Build Process Overhead - TypeScript compilation and bundling (Webpack/Vite) require significant CPU and memory during deployment, increasing build server costs and time

• Node.js Runtime Requirements - If using SSR (Next.js, Remix), you need Node.js hosting instead of simple static hosting, which is 3-5x more expensive than CDN/static file hosting

• Longer CI/CD Pipeline Execution - TypeScript type checking, linting, testing, and bundling extend build times, consuming more CI/CD minutes (costly on platforms like GitHub Actions, CircleCI)

• Larger Bundle Sizes - React apps with dependencies can produce large bundles requiring more bandwidth and CDN costs, especially without proper code-splitting

• Development Tooling Infrastructure - May need separate staging environments, preview deployments, and dev servers, multiplying hosting costs

• Memory-Intensive Builds - TypeScript + large React apps can require 2-4GB RAM during builds, forcing upgrades to higher-tier build machines or serverless functions

If you started a fresh project today, what's one tool you'd REFUSE to use?

Maneesh Thakur — Sat, 14 Feb 2026 09:43:34 +0000

A look at the technologies we've moved on from and why.

The Hype vs. The Headache
We spend so much time talking about the "New Shiny Stack," but we rarely talk about the tools that burned us. Whether it was a library with terrible documentation or a framework that felt like "magic" until it broke, we all have that one tech we've blacklisted.

My Take
=> For me, it's any library that tries to "hide" the underlying logic too much. I’d rather write 10 extra lines of code than spend 2 hours debugging a "black box" abstraction.

Your Turn
=> What tool or framework is officially "dead" to you?
=> What was the "last straw" that made you switch?

Is "Perfect Code" actually a myth in a fast-paced startup?

Maneesh Thakur — Fri, 13 Feb 2026 17:25:03 +0000

Discussion on balancing code quality with the need to ship features.

The Scenario
We’ve all been there. You have a beautiful architecture in mind—modular, DRY, and fully tested. But the deadline is in 3 hours, and the stakeholder just added a "minor" change that breaks your clean abstraction.

Do you:

Ship the "messy" if-else chain to meet the deadline?
Push back the launch to ensure the codebase stays pristine?

My Take
I’m starting to believe that "Good Enough" is a senior developer skill.
Technical debt is like a credit card it’s a tool if used wisely, but it’ll ruin you if you don't have a plan to pay it back.

Let's Discuss
Where do you draw the line?
What is the one thing you never compromise on, even under pressure? (For me, it’s database migrations!)

Drop your "shipping horror stories" in the comments! 👇

called and sent a message too, but no reply...

Maneesh Thakur — Fri, 13 Feb 2026 13:32:44 +0000

Keep Going !

Maneesh Thakur — Fri, 13 Feb 2026 04:26:17 +0000

Teams ... togetherness

Maneesh Thakur — Thu, 12 Feb 2026 19:11:03 +0000

## 🎉 Introducing AI Progress Controls

Maneesh Thakur — Sun, 25 Jan 2026 15:33:03 +0000

Stop rebuilding the same progress bars for every AI project.

If you've ever built an LLM app, you know the drill: spend 3 days implementing token streaming UI, model loading states, parameter sliders... again. And again.

I built what we all needed but kept rebuilding.

7 production-ready components designed specifically for AI/ML workflows. No more reinventing the wheel.

And now? Just npm install and you're ready to go. ⚡

⚡ What's Inside

▸ StreamProgress – Real-time token streaming + cost tracking

▸ ModelLoader – Multi-stage loading with memory usage

▸ BatchProgress – Concurrent operations dashboard

▸ QueueProgress – Position tracking with live ETAs

▸ RetryProgress – Exponential backoff visualization

▸ ParameterSlider – LLM controls (temperature, top-p, max tokens)

▸ ParameterPanel – Unified parameter management with presets

Plus: 4 visual styles, 4 animation effects, 3 size variants, 5 brand themes. Make it yours.

Try it now:

📦 https://www.npmjs.com/package/ai-progress-controls-react

💻 https://github.com/Maneesh-Relanto/ai-progress-controls

authorization library

Maneesh Thakur — Sun, 18 Jan 2026 17:02:45 +0000

🤔 How do you PROVE your authorization library won't fail in production?
Most teams would say : "We have unit tests" (fingers crossed 🤞)

Update from GITHUB Insights : *** 105 developers in 2 weeks already trust our approach. *** Here is why,

In RBAC algorithm , we went 4 layers deeper:

🧪 Layer 1: Property-Based Testing

🔗 Layer 2: Integration Testing

📈 Layer 3: Branch Coverage (95%+)

🔒 Layer 4: Automated Security Scanning

📊 The Numbers on Test Statistics:

🧪 Property tests: 1,500+ generated scenarios
🔗 Integration tests: 8 complete workflows
📈 Branch coverage: 95%+ (not just 95% line coverage)
🔒 Security scan: Dual scanners, continuous monitoring

Total validation points: 1,500+ test cases
Time to run: ~45 seconds

🔥Want to See More?


bash
# Clone the repo
git clone https://github.com/Maneesh-Relanto/RBAC-algorithm
cd RBAC-algorithm

Pls do share the feedback

DEV Community: Maneesh Thakur

RepoReady — Instant AI-powered onboarding for any GitHub, GitLab, or Bitbucket repo

The Community

What I Built

Demo

Code

How I Built It

Architecture: zero-backend, client-side only

File structure

Multi-provider AI

Multi-platform Git support

Prompt engineering

Challenges

Try It Yourself

LearnHub - A Community-First Learning Platform

The Community

What I Built

📚 Core Features

🎨 Design Excellence

Demo

Quick Demo Flow:

Code

Key Stats:

How I Built It

🛠️ Technology Stack

🏗️ Architecture Decisions

🎯 Key Features Implementation

📊 Data Model

🚀 Development Workflow

Thank You

prompt-run: Run .prompt files against any LLM from your terminal

The post

Quickstart (60 seconds)

What a .prompt file looks like

Commands

prompt run — run a prompt against any LLM

prompt diff — side-by-side output comparison

prompt validate — catch errors before runtime

prompt new — scaffold a new prompt file interactively

Providers supported

Use it as a Python library too

Use in CI / GitHub Actions

What this is NOT

Why not LangChain / promptfoo / Langfuse?

Links

MD Files Connector — Stop Losing Track of Your Markdown Docs

hosting cost - soaring

If you started a fresh project today, what's one tool you'd REFUSE to use?

Is "Perfect Code" actually a myth in a fast-paced startup?

called and sent a message too, but no reply...

Keep Going !

Teams ... togetherness

## 🎉 Introducing AI Progress Controls

⚡ What's Inside

authorization library

🧪 Layer 1: Property-Based Testing

🔗 Layer 2: Integration Testing

📈 Layer 3: Branch Coverage (95%+)

🔒 Layer 4: Automated Security Scanning

📊 The Numbers on Test Statistics:

What a `.prompt` file looks like

`prompt run` — run a prompt against any LLM

`prompt diff` — side-by-side output comparison

`prompt validate` — catch errors before runtime

`prompt new` — scaffold a new prompt file interactively