DEV Community: Pavithran M

From Prompts to Production: Building Civic-Tech AI Workflows with RICE + CRAFT

Pavithran M — Thu, 03 Sep 2026 20:11:53 +0000

I recently completed the Vibe Coding Workshop — Civic Tech Edition, working through four practical use cases designed around real municipal workflows.

The goal wasn't simply to “make an AI app.” The workshop focused on turning vague prompts into structured, testable, reliable workflows using RICE, CRAFT, explicit enforcement rules, and Git-based iteration.

1. From a Naive Prompt to a Reliable Classifier — UC-0A

The first challenge was a municipal complaint classifier.

The input contained citizen complaints that needed to be classified into an exact municipal taxonomy such as:

Pothole
Flooding
Streetlight
Waste
Noise
Road Damage
Heritage Damage
Heat Hazard
Drain Blockage
Other

Each complaint also needed a priority:

Urgent / Standard / Low

The initial naive prompt was simply:

“Classify this citizen complaint by category and priority.”

The problem became obvious quickly: a simple prompt can classify the topic, but it doesn't necessarily enforce severity detection, evidence, or consistent taxonomy.

For example, a complaint mentioning an injury, child, school, hospital, ambulance, hazard, fall, or collapse needed to be treated as urgent.

What I changed

I converted the requirements into explicit agent instructions and skills:

Exact category validation
Severity keyword detection
Evidence-based reasoning
NEEDS_REVIEW for ambiguous cases
Batch CSV processing
Handling malformed or missing rows

The final classifier was tested against the supplied Pune dataset and produced the expected results_pune.csv.

Key lesson:
A good prompt doesn't just tell an AI what to do. It defines what counts as correct.

2. Making AI Preserve Policy Details — UC-0B

The second use case was an HR leave-policy summarizer.

At first glance, this sounds straightforward:

“Summarize the policy document.”

But policy documents contain details that cannot safely be summarized away.

The document included requirements such as:

14-day advance notice
Written approval before leave begins
Unapproved absence resulting in LOP
Maximum 5-day carry-forward
January–March usage window
Medical certificate requirements
Multiple approval authorities for Leave Without Pay
Restrictions on leave encashment

The major failure modes were:

Clause omission · Scope bleed · Obligation softening

What I changed

The workflow was redesigned to explicitly preserve:

Numerical limits
Deadlines
Conditions
Approval authorities
Prohibitions
Consequences
Exceptions

I also added validation so the generated summary could be checked for required policy details rather than simply trusting the output.

The final workflow generated summary_hr_leave.txt and passed the policy-summary validation.

Key lesson:
For policy workflows, “approximately correct” is often incorrect. Important conditions and exceptions have to survive the transformation.

3. Making Data Analysis Respect Scope — UC-0C

The third challenge involved municipal budget analysis.

The dataset contained:

5 wards
5 budget categories
Monthly data for 2024
Actual spending values
Several deliberate null values

The task was to calculate growth for a specific ward and category, for example:

Ward 1 – Kasba → Roads & Pothole Repair

The main failure modes were:

Wrong aggregation level · Silent null handling · Formula assumption

This was important because an apparently reasonable calculation can become completely misleading if data from different wards or categories is accidentally combined.

What I changed

The implementation enforced:

Exact ward/category scope
Explicit MoM or YoY selection
Previous-period values
Formula displayed alongside each result
Explicit null detection
No calculation when required values are missing
Zero-division validation

The output correctly produced values such as:

July 2024 → +33.1% MoM
October 2024 → -34.8% MoM

Key lesson

Scope is part of correctness.

A mathematically correct formula applied to the wrong aggregation level is still a wrong answer.

4. Building a Safe “Ask My Documents” Agent — UC-X

The final use case brought everything together.

The task was to build an interactive policy Q&A system using three separate documents:

HR Leave Policy
IT Acceptable Use Policy
Finance Reimbursement Policy

The challenge wasn't just answering questions. It was preventing the model from combining information from different documents to create a permission that no document actually grants.

For example:

“Can I use my personal phone to access work files when working from home?”

The HR document may discuss remote work, while the IT policy specifically limits personal-device access.

The agent therefore needed to maintain source boundaries.

Enforcement rules

The final workflow required:

One supporting source document
Filename + section citation
No cross-document blending
No invented permissions
No hedged statements
Preservation of conditions and restrictions
Exact refusal for unsupported questions

For unsupported questions, the required response was:

“This question is not covered in the available policy documents…”

The test cases successfully demonstrated:

Annual leave carry-forward → HR 2.6–2.7
Slack installation → IT 2.3
Home-office allowance → Finance 3.1
Flexible-working culture → exact refusal
Leave Without Pay → HR 5.2

Key lesson

The most important part of a document Q&A system isn't just retrieval.

It's knowing when not to answer.

What I Learned

Across all four use cases, the biggest shift was moving from:

“Give the AI a prompt and see what happens.”

to:

“Define the task, failure modes, enforcement rules, skills, validation, and test cases before trusting the output.”

The workflow I followed was essentially:

Naive Prompt → Identify Failure → RICE Prompt → agents.md → skills.md → Code → Test → Analyze → Fix → Commit

Git also became part of the development process rather than just version control. Each UC was developed and committed separately, creating a traceable history of what failed, why it failed, and what changed.

The four use cases reinforced a simple principle:

Reliable AI isn't just about generating better answers. It's about designing systems that make incorrect answers harder to produce.

AI #VibeCoding #GenerativeAI #CivicTech #PromptEngineering #RICE #CRAFT #Git #SoftwareDevelopment #AIEngineering

Building and Testing an LLM-Powered Onboarding Agent Locally

Pavithran M — Thu, 03 Sep 2026 19:00:08 +0000

I recently built and tested an LLM-powered employee onboarding agent locally using Python, GitHub, and the Groq API.

The goal was to understand how an AI agent can combine an LLM with tools, structured data, workflow rules, and human approval to complete a practical business process.

What the Agent Does

The onboarding agent follows a tool-using workflow:

• Retrieves an employee profile from mock HR data
• Checks the employee’s compliance status
• Sends a compliance reminder when required
• Requests human approval when compliance is pending
• Provisions role-based access after approval
• Sends a welcome notification
• Completes the onboarding workflow

The project uses mock HR and compliance data, so access provisioning and notifications are simulated locally.

Technical Architecture

The agent orchestration runs locally, while LLM inference is handled through the Groq API.

Local Python Agent
↓
Employee Profile Tool
↓
Compliance Check Tool
↓
Notification Tool
↓
Access Provisioning Tool
↓
Groq API
↓
LLM Response
↓
Agent continues the workflow

This helped me understand an important distinction: the agent orchestration and tools can run locally, while the actual LLM inference can be provided through a remote API.

ReAct-Style Tool Calling

The workflow follows a ReAct-style pattern where the model determines the next action, selects a tool, receives an observation, and continues the workflow.

For a pending-compliance employee:

Get employee profile
↓
Check compliance
↓
Compliance = PENDING
↓
Send reminder
↓
Ask for human approval
↓
Approval received
↓
Provision access
↓
Send welcome notification
↓
Complete

For an employee whose compliance is already cleared:

Get employee profile
↓
Check compliance
↓
Compliance = CLEARED
↓
Provision access
↓
Send welcome notification
↓
Complete

This difference was useful for validating that the compliance state actually controls the agent’s behavior.

Engineering Work

During the project, I worked through the complete development workflow:

• Installed and verified Git and Python
• Created an Ed25519 SSH key
• Configured the Windows SSH agent
• Connected the SSH key to GitHub
• Forked and cloned the repository
• Configured origin and upstream remotes
• Created a dedicated development branch
• Created a Python virtual environment
• Installed project dependencies
• Ran the agent’s dry-run validation
• Connected the agent to Groq
• Tested the agent end-to-end
• Committed and pushed the changes
• Opened a pull request

Fixing a Model Compatibility Issue

During the first real agent run, I encountered a Groq API error:

The model “llama-3.3-70b-versatile” was no longer available, resulting in a 404 model_not_found error.

I verified the models available through the API and updated the agent to use:

openai/gpt-oss-120b

I also moved the model selection behind a single GROQ_MODEL constant instead of leaving the model identifier hardcoded.

This was a useful reminder that LLM integrations have dependency-management concerns just like other API integrations. Model identifiers and provider availability can change and break an otherwise working application.

Adding a New Test Scenario

The first task was to add a new employee:

EMP-2026-0849
Arjun Reddy
Software Engineer
L4
Platform Engineering

The employee was added to the mock HR database with a CLEARED compliance record.

I then ran the dry-run validation and executed the agent against the new employee.

The agent successfully detected the CLEARED compliance status and proceeded directly to access provisioning without triggering the human approval gate.

I also tested the existing pending-compliance employee to confirm that the human-in-the-loop behavior remained intact.

What I Learned

The biggest takeaway was that an AI agent is more than an LLM prompt.

A useful agent combines:

• LLM reasoning
• Tool calling
• Application state
• Business rules
• Guardrails
• Human-in-the-loop decisions
• External APIs
• Testing and observability

The LLM can determine what action should happen next, but the surrounding application defines what tools exist, what data is available, what actions are permitted, and when human approval is required.

That separation becomes especially important when moving from an AI demo toward a production system.

Final Thoughts

This project gave me hands-on experience with the complete lifecycle of a small AI agent: setting up the development environment, integrating an LLM API, debugging a model compatibility issue, implementing a new workflow scenario, testing different execution paths, and submitting the work through GitHub.

More importantly, it helped me understand how LLMs, tools, workflow state, and deterministic business rules can work together to automate a real-world process while keeping humans in control of sensitive decisions.

AI #AIAgents #LLM #GenerativeAI

RabbitMQ Installation on Windows: A Complete Setup & Troubleshooting Guide

Pavithran M — Mon, 03 Aug 2026 14:29:39 +0000

A real-world RabbitMQ installation journey on Windows—from installation to debugging Erlang compatibility, Windows services, management plugins, and startup failures.

Introduction

RabbitMQ is one of the most popular open-source message brokers used for asynchronous communication between applications. Whether you're building microservices, event-driven systems, or background processing applications, RabbitMQ provides a reliable messaging infrastructure.

Installing RabbitMQ on Windows appears straightforward:

Install Erlang
Install RabbitMQ
Enable the management plugin
Start the service

However, in practice, installation can quickly become complicated due to:

Erlang version mismatches
Incorrect environment variables
Windows service configuration
Plugin issues
Startup failures

This article documents the complete installation process along with the real troubleshooting steps required to get RabbitMQ running successfully.

Prerequisites

Before installing RabbitMQ, ensure you have:

Windows 10/11
Administrator privileges
Internet connection
Latest compatible Erlang OTP
RabbitMQ Installer

Step 1 — Install Erlang OTP

RabbitMQ depends on Erlang Runtime.

Install Erlang OTP from the official website.

After installation verify it.

erl

Expected output:

Erlang/OTP ...

Eshell V...
1>

If the command immediately returns to the command prompt, Erlang is not configured correctly.

Exit Erlang using:

q().

Step 2 — Configure Environment Variables

Create an environment variable.

ERLANG_HOME

Value

C:\Program Files\Erlang OTP

Also verify the PATH contains

C:\Program Files\Erlang OTP\bin

Verification:

echo %ERLANG_HOME%

where erl

Step 3 — Install RabbitMQ

Install RabbitMQ Server.

After installation verify the service.

sc query RabbitMQ

Expected

SERVICE_NAME: RabbitMQ

Step 4 — Enable RabbitMQ Management Plugin

Navigate to RabbitMQ sbin.

cd "C:\Program Files\RabbitMQ Server\rabbitmq_server-4.3.4\sbin"

Enable Management UI.

rabbitmq-plugins enable rabbitmq_management

Expected output

Enabling plugins on node rabbit@hostname...

rabbitmq_management
rabbitmq_management_agent
rabbitmq_web_dispatch

started 3 plugins

Step 5 — Restart RabbitMQ

net stop RabbitMQ

net start RabbitMQ

Or restart from

services.msc

Step 6 — Verify Installation

Open

http://localhost:15672

Default Login

Username : guest
Password : guest

RabbitMQ Default Ports

Service	Port
AMQP	5672
Management UI	15672
Erlang Distribution	25672

Real Troubleshooting Journey

This section documents every issue encountered during installation.

Problem 1

rabbitmq-plugins produced no output

Running

rabbitmq-plugins enable rabbitmq_management

returned immediately.

No output.

No error.

Normally RabbitMQ should display

started 3 plugins

Investigation

Checked

rabbitmq-plugins list

No output.

Checked

rabbitmqctl status

No output.

This indicated RabbitMQ tools were unable to communicate with Erlang.

Problem 2

Erlang immediately exited

Running

erl

returned directly to the command prompt.

Instead of

Eshell...

This confirmed Erlang itself wasn't functioning properly.

Problem 3

RabbitMQ Service Error 1067

Checking the service

sc query RabbitMQ

Result

STATE : STOPPED

WIN32_EXIT_CODE : 1067

Meaning

RabbitMQ started and terminated unexpectedly.

Problem 4

RabbitMQ Boot Failed

Instead of using the Windows service, RabbitMQ was started manually.

rabbitmq-server.bat

Output

BOOT FAILED

throw:{horus, extraction_denied,...}

Initially it appeared to be a configuration issue.

Problem 5

Configuration File

RabbitMQ loaded

advanced.config

The configuration file was renamed.

RabbitMQ still failed.

Therefore configuration wasn't the root cause.

Problem 6

Windows Service Error

Running

net start RabbitMQ

returned

System error 2

The system cannot find the file specified.

This was confusing because the RabbitMQ service already existed.

Root Cause Investigation

Instead of checking RabbitMQ logs repeatedly, the Windows service configuration was inspected.

sc qc RabbitMQ

Output

BINARY_PATH_NAME

C:\Program Files\Erlang OTP\erts-17.0.4\bin\erlsrv.exe

However, the installed Erlang version contained

erts-16.4

RabbitMQ was still pointing to the old Erlang runtime.

Windows therefore attempted to launch

erts-17.0.4

which no longer existed.

Hence

System error 2

Solution

Remove the existing RabbitMQ service.

rabbitmq-service.bat remove

Verify

echo %ERLANG_HOME%

Install the service again.

rabbitmq-service.bat install

Start RabbitMQ.

rabbitmq-service.bat start

Verify the service configuration.

sc qc RabbitMQ

RabbitMQ should now reference the current Erlang runtime.

Useful Commands

Verify Erlang

erl

Verify Environment Variable

echo %ERLANG_HOME%

Check Erlang Path

where erl

RabbitMQ Status

rabbitmqctl status

RabbitMQ Service Status

sc query RabbitMQ

RabbitMQ Service Configuration

sc qc RabbitMQ

Start RabbitMQ

net start RabbitMQ

Stop RabbitMQ

net stop RabbitMQ

Restart RabbitMQ

net stop RabbitMQ

net start RabbitMQ

Start RabbitMQ in Foreground

rabbitmq-server.bat

Enable Management Plugin

rabbitmq-plugins enable rabbitmq_management

List Enabled Plugins

rabbitmq-plugins list -E

Lessons Learned

There were several important takeaways from this debugging session.

Always verify Erlang first

Before installing RabbitMQ, ensure

erl

opens the Erlang shell.

Verify Environment Variables

Incorrect

ERLANG_HOME

or PATH configuration causes multiple RabbitMQ issues.

RabbitMQ Depends on Erlang Runtime

Reinstalling Erlang changes the runtime directory.

RabbitMQ Windows Service still references the previous runtime until the service is recreated.

Windows Service Errors Can Be Misleading

System error 2

did not mean RabbitMQ was missing.

It meant the service executable path referenced a missing Erlang runtime.

Use rabbitmq-server.bat

Instead of relying on Windows Service errors.

rabbitmq-server.bat

provides detailed startup diagnostics.

Always Verify Service Configuration

The most useful command during this debugging session was

sc qc RabbitMQ

It immediately exposed the incorrect Erlang runtime path.

Final Thoughts

RabbitMQ installation is usually straightforward, but Windows service configuration and Erlang compatibility can introduce subtle issues that are difficult to diagnose.

The key takeaway from this experience is to troubleshoot methodically:

Verify Erlang.
Verify environment variables.
Check RabbitMQ startup.
Inspect Windows service configuration.
Recreate the RabbitMQ service after changing Erlang versions.
Enable the management plugin only after the server starts successfully.

Following this process made it possible to move from repeated startup failures to a fully working RabbitMQ installation with the Management UI enabled.

If this guide helped you save hours of debugging, consider sharing it with other developers who are setting up RabbitMQ on Windows. It might save them from the same troubleshooting journey.

📬 Automate Email Attachments to Telegram with Python + Render.com

Pavithran M — Sun, 10 Aug 2025 13:00:11 +0000

Ever wished you could automatically forward email attachments to your Telegram chat or group? Whether it's invoices, reports, or alerts—this Python script does exactly that. And the best part? You can deploy it as a scheduled cron job on Render.com with zero hassle.

Let’s walk through the features, setup, and deployment steps to get this automation running in minutes.

🚀 What This App Does

This Python application:

✅ Connects securely to Yahoo Mail via IMAP
📂 Downloads the latest attachment from a specific folder (B2b)
📤 Sends the attachment to a Telegram chat or group using the Telegram Bot API
🧾 Logs each step for easy debugging
🕒 Runs automatically on a schedule using Render.com’s cron job feature

Perfect for automating workflows that rely on email-based file delivery.

🛠️ Tech Stack

Here’s what powers the app:

Python 3
imaplib – for accessing email via IMAP
email – for parsing MIME messages
requests – for sending files to Telegram
dotenv – for managing environment variables locally

📦 Getting Started

1. Clone the Repository

git clone https://github.com/your-username/email-to-telegram.git
cd email-to-telegram

2. Create a `.env` File (for local testing)

EMAIL_USER=your_yahoo_email@example.com
EMAIL_PASS=your_yahoo_app_password
TELEGRAM_TOKEN=your_telegram_bot_token
TELEGRAM_CHAT_ID=your_chat_id_or_group_id

⚠️ Use a Yahoo App Password instead of your regular password for IMAP access.

🧑‍💻 Local Testing

Run the script manually to verify everything works:

python script.py

You should see logs showing:

Connection to Yahoo Mail
Attachment download
Telegram API response

☁️ Deploying on Render.com

Render makes it super easy to automate this with a cron job.

Step 1: Create a New Cron Job

Go to Render Cron Jobs
Choose Python as the runtime
Set your schedule using cron syntax (e.g., 0 * * * * for hourly)

Step 2: Upload Your Code

Upload your script (script.py)
Include a requirements.txt with:

  requests
  python-dotenv

Step 3: Set Environment Variables

In the Environment section of the cron job setup:

EMAIL_USER
EMAIL_PASS
TELEGRAM_TOKEN
TELEGRAM_CHAT_ID

You don’t need the .env file on Render—just set the variables directly.

Step 4: Confirm and Deploy

Save and deploy the cron job
Check logs after the first scheduled run to confirm success

🧪 Troubleshooting Tips

No logs? Add print() statements to trace execution.
No attachment sent? Double-check the folder name (B2b) and email structure.
Telegram error? Make sure the bot isn’t blocked and has permission to send messages.

🧾 Final Thoughts

This setup is ideal for automating repetitive email-based workflows and keeping your Telegram feed updated with important files. You can easily extend it to support multiple folders, file types, or even filter by subject lines.

If you found this helpful, drop a ❤️ or share your own automation ideas in the comments!

Take a look at me!

🎮 Turning My GitHub into a Game — My First Step Toward Showcasing My Skills!

Pavithran M — Fri, 08 Aug 2025 17:28:12 +0000

Hey everyone 👋,

I've been working in the tech industry for almost 5 years, gaining hands-on experience in various technologies — particularly in .NET, SQL, application development, and database engineering.

But until now, I never really showcased my work, projects, or progress publicly.
Well... better late than never, right? 😄

🚀 What Sparked the Change?
Big shoutout to this amazing post by @vidakhoshpey22
It inspired me to transform my GitHub profile into a gamified contribution graph — featuring Pac-Man!

This was a fun and rewarding project that not only added visual flair to my profile but also kickstarted my journey into consistently recording and sharing my professional milestones.

🛠️ What I've Done So Far
✅ Setup a Pac-Man-themed contribution graph on my GitHub
✅ Created a dedicated Milestones repo to track all my achievements
✅ Committed to logging everything I learn or build going forward

🔗 Check out my GitHub: github.com/Pavithran-P12

✨ What’s Next?
This is just the beginning.
I'll be documenting more tasks, sharing bite-sized accomplishments, and contributing to open-source wherever I can.

If you're like me — experienced but haven't showcased much — this is your sign to start now. Share, track, and celebrate your journey 🎉

Happy coding everyone!
Happy developing! 💻🚀

DEV Community: Pavithran M

From Prompts to Production: Building Civic-Tech AI Workflows with RICE + CRAFT

1. From a Naive Prompt to a Reliable Classifier — UC-0A

What I changed

2. Making AI Preserve Policy Details — UC-0B

What I changed

3. Making Data Analysis Respect Scope — UC-0C

What I changed

Key lesson

4. Building a Safe “Ask My Documents” Agent — UC-X

Enforcement rules

Key lesson

What I Learned

AI #VibeCoding #GenerativeAI #CivicTech #PromptEngineering #RICE #CRAFT #Git #SoftwareDevelopment #AIEngineering

Building and Testing an LLM-Powered Onboarding Agent Locally

AI #AIAgents #LLM #GenerativeAI

RabbitMQ Installation on Windows: A Complete Setup & Troubleshooting Guide

Introduction

Prerequisites

Step 1 — Install Erlang OTP

Step 2 — Configure Environment Variables

Step 3 — Install RabbitMQ

Step 4 — Enable RabbitMQ Management Plugin

Step 5 — Restart RabbitMQ

Step 6 — Verify Installation

RabbitMQ Default Ports

Real Troubleshooting Journey

Problem 1

rabbitmq-plugins produced no output

Investigation

Problem 2

Erlang immediately exited

Problem 3

RabbitMQ Service Error 1067

Problem 4

RabbitMQ Boot Failed

Problem 5

Configuration File

Problem 6

Windows Service Error

Root Cause Investigation

Solution

Useful Commands

Verify Erlang

Verify Environment Variable

Check Erlang Path

RabbitMQ Status

RabbitMQ Service Status

RabbitMQ Service Configuration

Start RabbitMQ

Stop RabbitMQ

Restart RabbitMQ

Start RabbitMQ in Foreground

Enable Management Plugin

List Enabled Plugins

Lessons Learned

Always verify Erlang first

Verify Environment Variables

RabbitMQ Depends on Erlang Runtime

Windows Service Errors Can Be Misleading

Use rabbitmq-server.bat

Always Verify Service Configuration

Final Thoughts

📬 Automate Email Attachments to Telegram with Python + Render.com

🚀 What This App Does

🛠️ Tech Stack

📦 Getting Started

1. Clone the Repository

2. Create a .env File (for local testing)

🧑‍💻 Local Testing

☁️ Deploying on Render.com

Step 1: Create a New Cron Job

Step 2: Upload Your Code

Step 3: Set Environment Variables

Step 4: Confirm and Deploy

🧪 Troubleshooting Tips

🧾 Final Thoughts

🎮 Turning My GitHub into a Game — My First Step Toward Showcasing My Skills!

2. Create a `.env` File (for local testing)