DEV Community: Lokesh

I Built a Portable AI Skill That Safely Upgrades .NET Applications

Lokesh — Sat, 01 Aug 2026 01:16:02 +0000

I Built a Portable AI Skill That Safely Upgrades .NET Applications

AI coding assistants have become incredibly good at writing code.

But I kept running into the same problem...

When I asked an AI to upgrade a .NET application, the response usually looked something like this:

"Update the TargetFramework, update the NuGet packages, and build."

Anyone who has upgraded a real production application knows that's only a tiny part of the job.

A proper upgrade normally involves:

Choosing the correct supported .NET version
Updating Microsoft and third-party packages
Handling private NuGet feeds
Fixing vulnerable dependencies
Detecting deprecated packages
Removing unused packages safely
Updating Docker images
Updating CI/CD pipelines
Understanding breaking changes
Running builds and tests
Producing an upgrade report

That's not a prompt.

That's an engineering workflow.

So I decided to build one.

Introducing CoreLogic AI Skills

CoreLogic AI Skills is an open-source library of reusable engineering workflows designed for AI coding agents.

Instead of writing the same prompts repeatedly, each workflow is packaged as a reusable Skill.

The goal is simple:

Build once. Use with any AI coding agent.

The library currently supports:

Claude Code
Cursor
OpenCode
Codex
ChatGPT (packaged skills)

GitHub Repository:

👉 https://github.com/mrlokeshagarwal/corelogic-ai-skills

The first public skill: dotnet-upgrade

The first skill I created is called dotnet-upgrade.

Instead of blindly modifying a repository, it behaves more like an experienced senior engineer.

Phase 1 – Repository Assessment

It first analyses the repository.

It looks for things like:

Current .NET version
Solution structure
Project types
NuGet packages
Private package feeds
Vulnerable dependencies
Deprecated packages
Docker configuration
CI/CD pipelines

It then creates an upgrade plan.

Nothing is modified yet.

Phase 2 – Approval

One design decision was very important to me.

The skill never starts changing code immediately.

Instead it presents something like this:

.NET Upgrade Assessment

Current framework:
.NET 6

Recommended target:
.NET 10 LTS

Projects:
6

Vulnerable packages:
4

Deprecated packages:
2

Docker changes required:
Yes

CI/CD changes required:
Yes

No files have been modified.

Approve this plan?

Only after explicit approval does the upgrade begin.

Phase 3 – Upgrade

After approval the skill can:

Upgrade the target framework
Update NuGet packages
Handle private NuGet feeds
Fix vulnerable dependencies
Review deprecated packages
Remove unused packages carefully
Update Docker files
Update CI/CD pipelines
Resolve common upgrade issues

Phase 4 – Validation

The work isn't finished after changing code.

The skill validates the application by:

Restoring packages
Building the solution
Running tests
Publishing the application
Producing a comparison report

Because a successful build doesn't always mean a successful upgrade.

More than a prompt library

One thing I wanted to avoid was creating another repository full of prompts.

Instead, I built a small ecosystem.

The repository includes:

Reusable Skills
Generic installer
Multi-skill support
Validation tooling
Packaging utilities
GitHub Actions
Platform adapters
Automated tests
Documentation

Adding a new skill shouldn't require changing the installer or packaging logic.

Another included skill

The repository also includes start-story.

It helps developers begin work from an Azure DevOps work item by:

Retrieving the work item
Determining the correct repository
Creating or reusing the appropriate branch
Validating the implementation
Creating a Pull Request

Like dotnet-upgrade, it includes approval checkpoints before potentially destructive actions.

Why portable skills?

Every AI coding tool has its own way of working.

Some support Skills.

Some support Rules.

Some support Instructions.

Some support AGENTS.md.

I wanted the workflow itself to remain portable while only the discovery mechanism changed.

That's why the repository includes adapters for multiple platforms rather than maintaining completely different implementations.

What's next?

I'm planning to add more engineering-focused skills, including:

SQL Performance Review
.NET Code Review
Entity Framework Modernization
Architecture Review
CI/CD Pipeline Review
Security Audit
Dependency Modernization

I'd love your feedback

This is the first public beta.

If you use Claude Code, Cursor, OpenCode, Codex, ChatGPT—or any other AI coding assistant—I would really appreciate your feedback.

Which engineering workflow would you like to see turned into a reusable AI Skill?

⭐ GitHub Repository

https://github.com/mrlokeshagarwal/corelogic-ai-skills

Feedback, ideas and contributions are always welcome.

Thanks for reading!

Building a Reusable AI Workflow for Azure DevOps Work Items

Lokesh — Tue, 28 Jul 2026 00:09:09 +0000

Building a Reusable AI Workflow for Azure DevOps Work Items

AI is great at reasoning. It is terrible at remembering how your company likes to do Git.

Every week I implement dozens of Azure DevOps work items.

The process is always the same.

Read the work item
Understand the acceptance criteria
Find the correct repository
Create a branch
Search the codebase
Implement the change
Validate it
Commit
Push
Create a Pull Request

None of those steps are individually difficult.

They're just repetitive.

Naturally I thought:

"Why can't an AI agent do all of this?"

It turns out writing code is only about 20% of the workflow.

The remaining 80% is engineering discipline.

An AI agent can absolutely generate code.

But it doesn't automatically know:

which repository contains the feature
how your team names branches
which projects require manual validation
whether the working tree is already dirty
if another Pull Request already exists
how your product is organised

Those aren't intelligence problems.

They're workflow problems.

That's why I built Start Story.

Rather than creating another "AI coding assistant", I wanted to build something different:

A reusable workflow that safely takes an Azure DevOps work item all the way to a Pull Request while keeping a developer firmly in control.

The Goal

I had three design goals.

1. Remove repetitive work

I didn't want AI replacing developers.

I wanted it replacing ceremony.

If an agent can save me fifteen minutes on every ticket by handling Git operations and Azure DevOps plumbing, that's a meaningful productivity gain.

2. Make it reusable

The first version worked.

Unfortunately it only worked for my repositories.

Repository names were hardcoded.

Validation rules lived inside PowerShell.

Search guidance referenced my controllers.

It wasn't a reusable tool.

It was a diary entry that happened to execute.

I wanted something I could point at an entirely different product and have it work with minimal configuration.

3. Never sacrifice safety

Automation should reduce mistakes.

Not create new ones.

That meant every operation had to be deterministic.

No guessing.

No "probably".

No auto-merging.

No silently continuing after errors.

Human approval always remains the final step.

The Workflow

The finished workflow looks like this.

Azure DevOps Work Item
        │
        ▼
Read Story
        │
        ▼
Understand Acceptance Criteria
        │
        ▼
Detect Repository
        │
        ▼
Create or Reuse Branch
        │
        ▼
Agent Implements Change
        │
        ▼
Validate Repository
        │
        ▼
Developer Review
        │
        ▼
Commit
        │
        ▼
Push
        │
        ▼
Create Pull Request

Notice what isn't there.

Merge.

The workflow deliberately stops after creating the Pull Request.

Review is still performed by a human.

That decision alone removed a huge amount of risk.

The Biggest Design Mistake

Originally I thought this project was mostly about prompts.

It wasn't.

The biggest challenge was deciding what belongs where.

Everything had become mixed together.

PowerShell knew repository names.

Markdown knew folder structures.

Configuration files contained workflow logic.

Every change required editing multiple places.

Eventually I realised I wasn't building one system.

I was building three.

Three Layers Instead of One

The architecture eventually became surprisingly simple.

Layer	Responsibility
Scripts	Deterministic operations
Markdown	AI reasoning
Profiles	Product knowledge

Each layer has exactly one responsibility.

That sounds obvious.

It wasn't obvious while building it.

Layer One — Scripts

Scripts perform work that should always behave identically.

Examples include:

Git operations
Azure DevOps REST calls
Validation
Pull Request creation
Branch detection

A script should never need to "think".

It simply executes.

That makes scripts predictable and easy to test.

They become the safety rails around the AI.

Layer Two — Markdown

Markdown contains instructions for the coding agent.

Examples include:

implementation workflow
review checkpoints
coding expectations
reasoning guidance

Unlike scripts, markdown is expected to evolve.

As I discover better workflows, the instructions improve.

The scripts rarely change.

The prompts improve continuously.

That separation turned out to be incredibly valuable.

Layer Three — Repository Profiles

Every product has tribal knowledge.

Things like:

"Search this controller first."
"Business logic lives here."
"Ignore generated files."
"Don't modify this folder."

Originally those details lived inside prompts.

That meant every repository required editing the workflow.

Now they live inside repository profiles.

Changing products no longer requires changing the workflow.

Only the profile changes.

A Simple Rule

Eventually I settled on one design rule.

If it's deterministic, put it in a script.

If it requires judgement, put it in markdown.

If it's specific to one product, put it in a repository profile.

That single decision simplified almost every part of the project.

PR Bot: AI-Powered PR Reviews for Azure DevOps, GitHub & Bitbucket

Lokesh — Sun, 22 Feb 2026 23:32:15 +0000

In short: prbot is a CLI that uses Claude, GPT, or Cursor to review pull requests on Azure DevOps, GitHub, or Bitbucket. It posts structured feedback as PR comments, including inline feedback on specific lines. Configure once, run prbot review 42, and get AI-powered code reviews aligned with your team's standards.

Code reviews are critical for software quality — but they’re often slow, repetitive, and inconsistent.

What if a CLI tool could:

Fetch your PR
Apply your team’s coding standards
Send everything to Claude, GPT, or Cursor
Post structured feedback directly on the PR

That’s what prbot does.

prbot does exactly that. It's a lightweight CLI that fetches PR metadata and diffs from your source control platform, sends them to an AI (Claude, GPT, or Cursor), and posts the review as comments—including inline feedback on specific lines.

Why prbot?

How It Works

prbot fetches PR metadata and diffs from your source control platform.
It loads your CodeStandard.md.
It sends structured input to the selected AI provider (Claude, GPT, or Cursor).
The AI returns schema-validated JSON.
prbot posts the review as structured PR comments (including inline feedback).

No servers. No webhooks. Just a CLI.

Feature	Description
Multi-platform	Azure DevOps, GitHub, and Bitbucket Cloud
Your standards	Reviews against a custom `CodeStandard.md` file
Choice of AI	Claude (Anthropic), GPT (OpenAI), or Cursor Cloud Agents
Inline comments	Issues posted on the exact lines of code
Replace mode	Re-run reviews and replace old AI comments with fresh ones
Zero infrastructure	Just a CLI; no servers or webhooks to manage

Quick Start

# Clone and install
git clone https://github.com/mrlokeshagarwal/pr-bot.git
cd pr-bot
npm install
npm run build

# Make it global (optional)
npm link

Setup in 3 Steps

1. Choose your platform

Platform	Repo format	Auth
GitHub	`owner/repo`	Personal Access Token
Azure DevOps	`repo-name` or GUID	PAT
Bitbucket	`workspace/repo-slug`	App Password

GitHub:

prbot set platform github
prbot set repo owner/repo
prbot set github-token    # Prompts for your token

Azure DevOps:

prbot set platform ado
prbot set org https://dev.azure.com/YourOrg
prbot set project YourProject
prbot set repo YourRepo
prbot set pat            # Prompts for PAT

Bitbucket:

prbot set platform bitbucket
prbot set repo workspace/repo-slug
prbot set bitbucket-token

2. Add your coding standard

Create a CodeStandard.md with your team's guidelines. prbot sends this to the AI so reviews align with your rules.

prbot set standard C:\path\to\CodeStandard.md

3. Configure AI

# Claude (default)
prbot set provider claude
prbot set claude-key

# Or OpenAI
prbot set provider openai
prbot set openai-key
prbot set model gpt-4o

Run a Review

# Review PR #42
prbot review 42

# Dry run (see output without posting)
prbot review 42 --dry-run

# Replace old AI comments with a fresh review
prbot review 42 --replace

Tip: Use --dry-run on production PRs first to verify the output before posting comments.

What You Get

Each review includes:

Section	Description
Summary	High-level overview of the changes
Risk assessment	Potential issues or concerns
Questions	Clarifications the AI suggests
Issues	Specific findings with severity, file, line, and code snippets

All comments are prefixed with [AI Review] so you can easily identify and filter them.

Tech Stack

Technology	Purpose
TypeScript	Type-safe, modern JavaScript
Node.js 18+	Native `fetch`, no extra HTTP libs
Commander	CLI framework
Zod	Schema validation for AI responses
diff	Unified diff generation for Azure DevOps

Get Started

GitHub: github.com/mrlokeshagarwal/pr-bot

git clone https://github.com/mrlokeshagarwal/pr-bot.git
cd pr-bot
npm install && npm run build
prbot status   # Verify setup

Project Status

This is an early-stage project. The code has not been formally tested across all platforms and edge cases. Use with caution on production PRs—consider running with --dry-run first to verify output before posting comments.

Disclaimers

Trademarks: Azure DevOps, GitHub, and Bitbucket are trademarks of their respective owners. Claude, GPT, and Cursor are trademarks of Anthropic, OpenAI, and Cursor, respectively. This project is not affiliated with or endorsed by Microsoft, GitHub, Inc., Atlassian, Anthropic, OpenAI, or Cursor.

Terms of Service: Use of prbot is subject to the terms of service of the AI providers (Anthropic, OpenAI, Cursor) and source control platforms (Azure DevOps, GitHub, Bitbucket) you connect to. Ensure your usage complies with their respective policies.

If you use Azure DevOps, GitHub, or Bitbucket and want consistent, AI-assisted code reviews, give prbot a try.

⭐ Star the repo if you find it useful

💬 Feedback and contributions are welcome