DEV Community: Sumeet Naik

I Built an AI Pipeline That Writes My Tech Posts While I Code

Sumeet Naik — Fri, 29 May 2026 07:53:58 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Hermes Content Pipeline: a daily dev-to-social content workflow that turns your actual development work into LinkedIn, Twitter, and blog drafts, delivered to Telegram for review.

The problem: as a developer with a full-time job, I was doing meaningful work every day but never publishing about it. The friction wasn't the writing, it was the capture. By the time I sat down to draft a post, I'd forgotten the trade-offs I'd weighed, the bugs I'd worked around, and the decisions that shaped the work.

The pipeline solves this in three steps:

Auto-capture during work: A Hermes skill (content-capture) automatically logs trade-off decisions, bugs (as principles, not raw debugging), and task completions to a sidecar notes file as you work. No interruption, no extra input needed.
"Draft posts for today's tasks": A Python script parses the session database and sidecar notes into a structured prompt, then a skill calls the LLM to generate three drafts: a ~300 word LinkedIn post, a Twitter thread (or single tweet, contextually chosen), and a substantive blog post.
Review and refine from mobile: All three drafts land on Telegram. Reply with "make linkedin shorter" or "focus on the auth bug in twitter" and the refinement skill re-generates only the affected draft.

The key insight: the best dev content comes from real work, not from staring at a blank page. This pipeline eliminates the blank page by deriving posts from what you already did.

Demo

Here's the pipeline in action, a real session where I built the project itself:

Input: Sidecar notes from a work session:

// trade: Sidecar file over DB column — keeps notes portable — needs manual cleanup
// trade: Minimal approach over fully integrated — simpler, no cron complexity
// bug: Telegram Markdown parsing rejects some characters — built fallback to plain text
// note: Built content-capture skill that auto-logs trade-offs during sessions
// note: Built draft_posts.py pipeline — reads state.db + notes, calls LLM, generates drafts

Output (LinkedIn draft, 140 words after refinement):

Every developer has a graveyard of half-formed ideas — debugging discoveries, architecture trade-offs, patterns that took hours to find.

I've been building content capture into our tooling, and the biggest lesson: capture is everything.

We use a simple sidecar file for logging insights. Manual cleanup required. No cron jobs. No automation.

And that simplicity is the feature.

The minimal approach — agent-driven markers, a flat file, simple pipeline — has been more useful than any elaborate setup I've attempted.

Do you have systems to capture lessons from your dev sessions, or does most of it stay trapped in your head?

Refinement in action: Started at ~300 words, refined down to 140 with "make linkedin more concise, under 150 words"

Code

Repository: github.com/sumeetweb/hermes-content-pipeline

├── skills/
│   ├── content-capture/SKILL.md       # Auto-logging during sessions
│   ├── content-generator/SKILL.md     # LLM-driven draft generation
│   └── refine-posts/SKILL.md          # Natural language refinement
├── scripts/
│   ├── parse_drafts.py                # Session parsing + prompt building
│   └── telebot_send.py                # Telegram delivery
├── tests/                             # Unit tests
└── run.sh                             # Venv-aware runner

My Tech Stack

Hermes Agent: session logging (SQLite state.db), skill system, Telegram gateway
Python stdlib: SQLite3, json, pathlib, urllib (Telegram Bot API)
OpenAI SDK: LLM calls using whatever model Hermes is configured with (minimax-m2.7 via Ollama Cloud in my setup)
Hermes Skill Framework: YAML frontmatter + markdown for the auto-logging skill

How I Used Hermes Agent

This project leans on four Hermes Agent capabilities that no other agent framework provides as cleanly:

1. Session Database (state.db)

Hermes stores every conversation in a local SQLite database with full message history. The parse_drafts.py script queries this directly, no API, no export step, no manual copy-paste. The session transcript IS the source of truth. This is what makes "derive posts from real work" possible without any extra effort from the user.

2. Skill System for Zero-Friction Capture

The content-capture skill uses Hermes' skill framework (YAML frontmatter + markdown body) to instruct the agent to automatically log // trade:, // bug:, // note: markers to a sidecar file. The agent recognizes significant moments during the session and logs them silently. The user never has to stop what they're doing.

3. Model-Agnostic LLM Config

The skill layer reads model and provider settings directly from ~/.hermes/config.yaml and ~/.hermes/.env. It inherits whatever model the user is already running. I'm using minimax-m2.7 via Ollama Cloud, but someone else could be on Claude, GPT-4o, or DeepSeek and it would just work.

4. Telegram Gateway Integration

Hermes' Telegram gateway config and channel directory (channel_directory.json) means the pipeline can discover the bot token and home chat ID automatically. No environment variable setup, no manual configuration. The drafts arrives to the user directly on their phone.

Why Hermes was the right fit: Other agent frameworks would require building the session logging, skill system, and messaging integration from scratch. Hermes provides all three out of the box, and the content pipeline simply connects them. The project is ~600 lines of Python + 2 skills connecting existing Hermes infrastructure, not ~3000 lines reinventing it.

Team Dashboard - Manage Your Team Efficiently with KendoReact

Sumeet Naik — Sun, 28 Sep 2025 20:11:27 +0000

This is a submission for the KendoReact Free Components Challenge.

What I Built

Team Dashboard is an enterprise-grade team performance dashboard that revolutionizes how managers track productivity, attendance, and KPIs across distributed teams. Built with React and powered by KendoReact's professional UI components, this application transforms complex performance data into actionable insights.

🎯 Problems Solved:

Data Accessibility Challenge: Traditional performance management often involves scattered spreadsheets, complex reports, and time-consuming data gathering. Team Dashboard centralizes all employee metrics in an intuitive, searchable interface.

Historical Analysis Bottleneck: Managers typically struggle to access past performance data quickly. Our AI-powered natural language query system allows instant access to historical insights with simple conversational queries like "Show me Q2 results for developers in Bangalore".

Team Management Complexity: Managing large teams requires efficient CRUD operations for employee data. The dashboard provides professional-grade employee management with inline editing, bulk operations, and smart filtering.

Visual Analytics Gap: Raw performance data is difficult to interpret. TeamPulse Pro includes interactive charts and trend analysis that transform numbers into visual stories managers can act upon.

🏢 Target Users:

Engineering Managers tracking developer productivity and code quality metrics
HR Directors monitoring employee satisfaction and retention indicators
Department Heads analyzing team performance across multiple locations
C-Suite Executives requiring high-level performance overviews with drill-down capabilities

🎥 Video Walkthrough

🚀 Live Application

Demo URL: Click Here
Repository: https://github.com/NishikantaRay/KendoReact-Free-Components-Challenge

📸 Screenshots & Features

Main Dashboard Interface

Employee data grid with real-time search, sorting, and filtering capabilities

AI-Powered Query Assistant

Natural language query interface powered by Nuclia RAG technology

Performance Analytics

Interactive performance trends and KPI visualizations

Employee Management Dialog

Professional forms for employee data management with validation

KendoReact Components Used

We successfully integrated 12 free KendoReact components throughout the application:

Core Data Components:

Grid - The centerpiece employee data grid with sorting, filtering, and pagination
GridColumn - Individual column definitions with custom rendering
GridToolbar - Action toolbar for grid operations

User Interface Components:

Button - Used extensively across all dialogs and action bars
Input - Text input fields for search and form data entry
Switch - Toggle controls for dark mode and compact view settings

Form & Selection Components:

DatePicker - Date selection for employee hire dates
DropDownList - Team and role selection dropdowns with filtering capabilities

Modal & Navigation Components:

Dialog - Modal windows for employee add/edit operations
DialogActionsBar - Standardized button containers for dialog actions

Feedback Components:

Notification - Individual notification messages for user feedback
NotificationGroup - Container managing multiple notification instances

AI Coding Assistant Usage

We extensively leveraged AI coding assistance throughout the development process, which significantly accelerated my workflow:

Component Architecture & Setup

Rapid Scaffolding: Used AI to generate initial component structures and establish proper KendoReact imports
Best Practices Implementation: AI helped ensure proper component organization and React hooks usage
Configuration Assistance: Streamlined the setup of complex grid configurations and chart integrations

Code Generation & Optimization

CRUD Operations: AI accelerated the development of create, read, update, and delete functionality for employee management
State Management: Helped implement efficient React state patterns for handling employee data and UI states
Event Handling: Generated robust event handlers for grid operations, form submissions, and user interactions

Styling & Responsiveness

CSS Integration: AI assisted in properly integrating KendoReact themes with custom styling
Responsive Design: Helped create layouts that work seamlessly across desktop and mobile devices
Theme Consistency: Ensured consistent styling patterns throughout all components

Debugging & Problem Solving

Error Resolution: AI provided solutions for component integration challenges
Performance Optimization: Suggested improvements for grid rendering and data handling
Cross-browser Compatibility: Helped identify and resolve potential browser-specific issues

Natural Language Query System:

We integrated Nuclia's AI capabilities directly into the dashboard sidebar, creating an intelligent assistant that allows managers to query historical performance data using conversational language.

Some Sample Queries Supported:

"Show me Q2 results for developers in Bangalore"
"What was the average performance score last month?"
"Which team has the highest productivity?"
"How many employees joined in 2024?"

Thank you for considering our submission for the KendoReact Free Components Challenge!

Team Members:

TravelMate AI: Real-Time AI Travel Planner Powered by Redis Stack

Sumeet Naik — Sat, 09 Aug 2025 21:47:59 +0000

This is a submission for the Redis AI Challenge: Real-Time AI Innovators.

What I Built

TravelMate AI is an intelligent travel planning application that demonstrates Redis capabilities beyond traditional caching. The application leverages semantic caching, vector search, and real-time features to provide instant, personalized travel recommendations and itinerary planning.

Demo

GitHub Repository: https://github.com/sumeetweb/TravelMate-Redis-AI

Live Demo Video: https://www.youtube.com/watch?v=cReF-pLsH-g

Screenshots

Homepage:

Without Redis Cache:

With Redis Cache:

Day-wise Itinerary Info:

Itinerary Info Map View:

How I Used Redis 8

TravelMate AI showcases Redis as a comprehensive AI application platform through multiple advanced features:

1. Vector Search & Semantic Caching

Vector Database: Storing query embeddings for semantic similarity matching
HNSW Algorithm: Efficient nearest-neighbor search for query similarity detection
Intelligent Caching: 95% similarity threshold for cache hits, eliminating redundant AI calls

2. Redis JSON for Complex Data Storage

Structured Itineraries: Complete travel plans stored as JSON documents without serialization overhead
Location Metadata: Detailed place information with coordinates, descriptions, and timing
User Preferences: Session context and personalization settings as JSON objects

3. Real-time Communication with Pub/Sub

Live Updates: Server-Sent Events pipeline powered by Redis Pub/Sub
Progress Indicators: Real-time streaming of AI generation progress to frontend
Multi-client Support: Concurrent user sessions with isolated event streams

4. Event Logging with Redis Streams

Complete Audit Trail: Every user interaction logged with timestamps
Event Sourcing: Replay capabilities for debugging and optimization
Session Flow: Complete interaction sequences for user experience analysis

5. Performance Monitoring with TimeSeries

Real-time Metrics: Response times, cache hit rates, and performance trends
Live Dashboard: Streaming performance data to frontend analytics
Historical Analysis: Time-based performance tracking with granular data points

Technical Architecture

Frontend (React/Next.js) 
    ↕ WebSocket/SSE
Backend API (Node.js/Express)
    ↕ 
Redis Stack (Vector Search, JSON, Pub/Sub, Streams, Embeddings Cache)
    ↕
OpenAI API (GPT-4, Embeddings)

TravelMate AI proves Redis isn't just fast storage - it's an intelligent platform for modern AI applications. From semantic understanding to real-time experiences, Redis powers every aspect of intelligent travel planning. The question isn't whether Redis can handle AI workloads, but how much more can you build when you stop thinking of Redis as just a cache?

DEV Community: Sumeet Naik

I Built an AI Pipeline That Writes My Tech Posts While I Code

What I Built

Demo

Code

My Tech Stack

How I Used Hermes Agent

Team Dashboard - Manage Your Team Efficiently with KendoReact

What I Built

🎯 Problems Solved:

🏢 Target Users:

🎥 Video Walkthrough

🚀 Live Application

📸 Screenshots & Features

Main Dashboard Interface

AI-Powered Query Assistant

Performance Analytics

Employee Management Dialog

KendoReact Components Used

AI Coding Assistant Usage

Component Architecture & Setup

Code Generation & Optimization

Styling & Responsiveness

Debugging & Problem Solving

Natural Language Query System:

Team Members:

TravelMate AI: Real-Time AI Travel Planner Powered by Redis Stack

What I Built

Demo

Screenshots

How I Used Redis 8

1. Vector Search & Semantic Caching

2. Redis JSON for Complex Data Storage

3. Real-time Communication with Pub/Sub

4. Event Logging with Redis Streams

5. Performance Monitoring with TimeSeries

Technical Architecture

Team Submission: Team JCoders