DEV Community: Pawan Sharma

Build AIRA - Powered Content Agents for Xperience by Kentico - in Under 5 Minutes

Pawan Sharma — Tue, 17 Mar 2026 03:45:05 +0000

Hey Kentico fam - Kentico Xperience just dropped its February 2026 refresh, and it's a gamechanger for us CMS devs. I'm talking to native AIRA agents - agentic AI right in the admin that autonomously handles content strategy, tone audits, and optimizations. No more hours tweaking pages manually.

In this post, I'll walk you through building your first AIRA-powered content agent live in under 5 minutes. We'll use the new Content Strategist agent (part of the AIRA suite), extend it with a tiny C# SDK snippet, and benchmark the speedup. As a Kentico expert at Dotstark and AWS Community Builder, I've tested this on real client sites - 10x faster content workflows, period.

Let's dive in.

The Problem: Manual Content Ops Are Killing Productivity

Picture this: You're migrating a site to Xperience. You need to audit 50 pages for brand voice, optimize SEO titles, and schedule A/B tests. Pre-AIRA Agents? That's 2-3 hours of copy-pasting into ChatGPT, cross-checking guidelines, and praying nothing breaks.

Enter agentic AI - not just chatbots, but autonomous agents that plan, reason, and act. Kentico's Feb 23 refresh baked this into Xperience v31.1+ with AIRA: the Content Strategist agent evaluates pages against your custom tone profile, suggests rewrites, and even publishes via API. I clocked a 100-page audit at 4 minutes flat.

What Makes AIRA Different

Unlike generic AI tools, AIRA agents are platform-native. They ingest your entire Xperience ecosystem - content libraries, Page Builder widgets, reusable content items - for context-aware decisions. The Content Strategist isn't guessing; it's analyzing against your actual Content Strategy document (uploaded as governance artifact) with:

Style compliance checks – Flags terminology mismatches, grammar issues, capitalization errors with severity levels (Critical, Major, Minor)
Tone evaluation – Ensures content matches audience expectations (tutorial vs. product page tone)
Voice alignment – Rates brand voice attributes (Friendly, Clear, Helpful) as Strong/Adequate/Weak with evidence

This is an agentic workflow at its finest—governed, logged, transparent, with admin-configured guardrails.

Step 1: Fire Up Xperience (2 Minutes Setup)

If you don't have an Xperience instance:

Head to kentico.com/trial → Spin up Cloud edition (free 30 days)
Log in → AIRA tab (left nav, new in v31)
Enable Content Strategist agent in Feature Settings

Upload your Content Strategy document (PDF/DOCX with voice, tone, style rules)

Pro tip: Link your Azure OpenAI key in AIRA Config for custom models. I use GPT-4o for speed. Commercial data protection is built-in—no data logging, no model training on your content

Step 2: Your First Agent Run (90 Seconds)

Navigate to Pages app → Pick a sample page (or create: "About Us")
Click AIRA chat icon → Type natural language prompt
Example prompt: "Run Content Strategist on this page. Target persona: enterprise CTOs. Content type: product page. Evaluate against Dotstark brand voice."

Boom — agent responds in seconds with structured findings:

Table 1: Sample Content Strategist output with severity-prioritized findings

Agent provides:

Exact text quotes for each issue
Suggested rewrites aligned to your Content Strategy
Quick-fix buttons for common refinements (shorten, improve grammar)

This isn't generic feedback - it's your brand guidelines enforced at scale.

Step 3: Go Dev Mode - SDK Extension (2 Minutes Code)

For automation at scale, hook agents into .NET workflows. While AIRA's C# SDK for direct agent invocation is still in preview, you can integrate with AIRA features programmatically using existing APIs.

Here's my battle-tested pattern for automated content refinement:
`using Kentico.Xperience.Admin.Base;
using Kentico.Xperience.Admin.Base.FormAnnotations;

// Enable AIRA refinements in custom Page Builder widget
public class ContentOptimizationWidgetProperties : IWidgetProperties
{
[RichTextEditorComponent]
[FormComponentConfiguration(typeof(AiraTextRefinementConfigurator))]
public string PageContent { get; set; }

// AIRA automatically applies refinements when content is saved
// Integrate with workflow events for audit logging

}

// Trigger via Xperience event system
public class ContentAuditHandler : IEventHandler
{
public async Task HandleAsync(PageUpdateEvent eventData)
{
// Custom logic: if page saves with AIRA suggestions pending,
// log to CloudWatch, notify content team via SNS
var auditLog = new AuditEntry
{
PageId = eventData.PageId,
Timestamp = DateTime.UtcNow,
AiraFindingsCount = eventData.PendingSuggestions.Count
};

await _logger.LogToCloudWatchAsync(auditLog);

}

} `

Real-world pattern: Deploy to AWS Lambda triggered by Xperience webhooks. Page saves → Lambda checks for AIRA suggestions → Auto-applies approved refinements → Publishes optimized version.

Real Speed Benchmarks (I Timed It)

Tested on 100 legacy pages migrated from Umbraco to Xperience:

Table 2: Real-world performance comparison showing AIRA agent acceleration

Numbers don't lie—agents chain tasks autonomously (audit → evaluate → suggest → refine). The Content Strategist handles discrete workflows with full transparency and logging.

Scaling for Enterprise: AWS + Xperience Architecture

Serverless deployment – Wrap AIRA workflows in Lambda functions, trigger via Xperience webhooks
Secure access – IAM roles + Xperience API keys (rotate via Secrets Manager)
Monitoring – AIRA audit logs in Xperience Insights + CloudWatch metrics

Content governance – Upload brand guidelines as Content Strategy docs, version-controlled in S3
Multi-region – Xperience Cloud + AWS edge for global content delivery

I've deployed this for 3 clients—content teams now focus on strategy, not grunt work. One SaaS client saw 25% engagement boost after localizing for APAC markets with consistent AIRA-enforced voice.

Beyond Content Strategist: What's Coming

Kentico's AIRA Agentic Marketing Suite is expanding with additional agents in preview:

Customer Journey Optimizer – Flags progression leaks, surfaces bottlenecks
Campaign Execution Agent – Auto-setup campaigns, surface performance insights
Analytics Agent – Convert insights to actionable recommendations

All orchestrated via AIRA's conversational hub, with headless architecture ensuring seamless delivery across channels.

Image Processing Bonus Features

While testing Content Strategist, I discovered AIRA's image automation—massively underrated:

Auto focal point selection – AI picks optimal crop for image variants (max 20MB, 50x50px min)
SEO descriptions – Generates alt text during mass upload in current language
Smart tagging – Assigns taxonomy tags based on image content analysis

Combined with content agents, you're automating 80% of routine CMS tasks.

Practical Implementation Tips

From my production deployments:

Start with Content Strategy – Upload comprehensive brand guidelines (voice, tone, terminology, style rules). Agent quality depends on this foundation.
Use persona + content type – Always specify when evaluating pages. "Tutorial for developers" gets different tone analysis than "product page for executives".
Integrate with workflows – Connect AIRA events to your CI/CD pipeline. My setup: page save → Lambda audit → Slack notification if Critical findings.
Monitor credit usage – Check AIRA dashboard for credit balance. Each agent run consumes credits based on complexity.
Iterate on prompts – Natural language works, but specific prompts yield better results. "Evaluate against Section 3.2 of brand guidelines" > "check tone".

The Technical Foundation

AIRA agents run on Azure OpenAI with commercial data protection guarantees:

No customer data stored or logged
Prompts/responses discarded after interaction
Not used for model training
Enterprise-grade privacy compliance

For developers, AIRA features integrate via:

FormComponentConfiguration attributes for widget properties
ExcludeFromAiraTranslation attribute for Page Builder components
Event system for workflow automation
Global config in appsettings.json (CMSEnableAira toggle)

Wrapping Up: Your Move

AIRA agents aren't future tech—they're shipping today in Xperience v31.1+. The Content Strategist alone cuts content ops time by 80%, and it's just the first agent in the suite.

*Action steps: *

Spin up Xperience trial (kentico.com/trial)
Enable Content Strategist in AIRA settings
Upload your brand guidelines as Content Strategy
Run your first evaluation on existing pages
Integrate with your AWS Lambda deployment for scale

Kentico #KenticoXperience #AIRA #AgenticAI #AWSTips #CloudDev #ContentAutomation #KenticoWithPawan

Building in Public: My Experience as an AWS Community Builder and Lessons for Future Applicants

Pawan Sharma — Tue, 30 Dec 2025 09:54:11 +0000

Introduction

Last year, I was selected as an AWS Community Builders. While the acceptance email was exciting, the real value of the program became clear only after spending time within the community - learning, contributing, and growing alongside builders from across the world.

This article is a reflection on that journey. It is written for anyone considering applying in an upcoming cycle and wondering what actually matters beyond the application form.

What the AWS Community Builders Program Really Is

From the inside, the program is best described as a working community, not a badge.

AWS Community Builders are individuals who actively:

Share AWS knowledge
Support peers through real-world problem solving
Engage consistently with the broader AWS ecosystem

The program provides structure, access, and enablement - but the impact comes from how members use those opportunities.

What Happened After I Was Selected

Once on boarded, I quickly realized that the biggest advantage was access to people.

Through the Community Builders Slack workspace and sessions:

I learned directly from experienced practitioners
I gained early visibility into AWS services and best practices
I exchanged ideas with builders working on diverse use cases
I received constructive feedback on content and technical topics

This environment encourages asking thoughtful questions and sharing practical experience rather than chasing visibility.

What You Actually Gain After Being Selected as an AWS Community Builder

Once you are selected, the program offers a combination of technical enablement, community access, and practical benefits. Based on my experience, these are the most meaningful ones:

1. Direct Access to a Strong AWS Builder Network

The private Community Builders Slack workspace is where most of the real value exists. It allows you to:

Discuss real-world AWS challenges with experienced builders
Learn from diverse use cases across industries
Get fast, practical feedback on technical ideas and content

This peer learning environment significantly accelerates growth.

2. AWS Credits for Hands-On Learning

Community Builders receive AWS credits that can be used for:

Personal experiments and proof-of-concepts
Learning new AWS services without cost pressure
Building demos, labs, or sample architectures

This encourages deeper hands-on exploration.

3. Exclusive Technical Sessions and Briefings

AWS regularly organizes sessions exclusively for Community Builders, covering:

Deep dives into AWS services
Best practices and architectural guidance
Early insights into upcoming features

These sessions often go beyond what is available publicly.

4. Early Access to AWS Services and Features

Being part of the program sometimes provides early visibility or access to new services and capabilities, helping you:

Stay ahead of the learning curve
Create relevant content early
Experiment before features reach general availability

5. Support for Content Creation and Community Growth

AWS encourages Community Builders to:

Improve technical writing and presentations
Grow their reach responsibly
Share accurate, high-quality knowledge

The focus is always on value, not marketing.

6. Recognition Within the AWS Ecosystem

While not the primary goal, being a Community Builder helps:

Build credibility within the AWS community
Open doors to collaborations, events, and speaking opportunities
Connect with AWS experts and industry leaders

This recognition comes naturally from consistent contribution.

How Being a Community Builder Changed My Approach

1. I Became More Intentional About Sharing

Instead of focusing on “what will perform well,” I started sharing:

Lessons from real projects
Common mistakes and how to avoid them
Clear explanations of complex topics

The emphasis shifted from reach to usefulness.

2. Community Engagement Became a Two-Way Street

The program reinforced an important mindset: contribution is not one-directional.

Helping others led to:

Better understanding of AWS services
Exposure to new perspectives and architectures
Strong professional relationships

You gain as much as you give.

3. Learning Accelerated Through Peer Discussions

Discussions within the community often go deeper than public forums. Seeing how others approach design decisions, cost optimization, or security trade-offs provided insights that documentation alone cannot offer.

Advice for Those Planning to Apply

Based on my experience, here is what truly helps:

Start Contributing Before You Apply

Write, speak, mentor, or support - long before the application opens.

Be Consistent, Not Perfect

Regular, honest contribution matters more than polished output.

Engage With the Community

Attend events, comment thoughtfully, and help when you can.

Write a Genuine Application

Your application should reflect your real journey, motivations, and impact. Avoid scripted or generic responses.

Important note: Do not use AI tools to write your application responses. AWS values authentic, personal input.

Benefits You Can Expect (Beyond the Obvious)

While the program includes tangible benefits such as AWS credits, learning resources, and exclusive sessions, the most valuable benefit is the network.

Being part of a group that values:

Learning in public
Helping without expectation
Technical depth with humility

creates long-term professional growth.

Final Thoughts

Becoming an AWS Community Builder is not about being the loudest voice - it is about being a reliable one.

If you are preparing to apply:

Focus on consistent contribution
Share what you genuinely learn
Support others whenever possible

The application will then feel like a summary of your journey—not a starting point.

If you plan to apply in an upcoming cycle, I wish you the very best. And if you get selected, reach out—I would be happy to connect and learn together.

Migrating Media Libraries to Content Hub in Xperience by Kentico – A Hands-On Project Case Study

Pawan Sharma — Mon, 17 Nov 2025 15:12:07 +0000

Yesterday, I completed a Media Library migration to Content Hub in a project, and I thought it would be great to share the complete experience here.

As most of you already know, Media Libraries have been officially sunset in Xperience by Kentico. Their related API members are now marked as obsolete, and support will end on July 24, 2026. After that date, the entire feature and associated APIs will be removed.

If your project still relies on Media Libraries, it’s the right time to start planning your migration. In our case, the client’s application was still using Media Libraries extensively, so we took the opportunity to move everything to Content Hub and adopt Content Item Assets, which is now the recommended and future-ready approach for managing media files in Kentico.

Why the Migration Was Needed

Media Libraries have been around for years and served their purpose well. However, they were tightly coupled with legacy APIs and didn’t align with Kentico’s new content modeling approach.

Content Hub, on the other hand, provides a centralized and structured way to manage all your digital assets. It offers:

A more flexible content model
Better metadata and permissions handling
Integration with modern workflows
Long-term compatibility with Kentico’s evolving architecture

For our project, moving to Content Hub was not only about compliance but also about future-proofing the solution.

Migration Overview

The migration process was smoother than I expected — thanks to Kentico’s built-in Media Library Migration Tool.

Here’s the overall process we followed:

1. Migrate Media Library files to Content Hub
2. Create a database backup
3. Set up the local development environment
4. Migrate fields referencing media files
5. Update the codebase
6. Deploy changes
7. Delete old Media Libraries

Let me walk you through each phase in more detail.

Step 1 – Migrate Media Library Files to Content Hub

This is the main step where all your existing media library files get converted into Content Item Assets.

Once I opened the Media Libraries application, I used the new migration option. When you click “Migrate Media Libraries”, Kentico creates a workspace named “Migration from Media Libraries” in the Content Hub.

Here’s what I really liked:

The folder hierarchy is fully preserved (e.g., a file in ~/AcmeLibrary/Icons/ stays under the same structure in Content Hub).

All GUIDs, custom fields, and system fields remain intact.

Permissions from the original media libraries automatically carry over.

Also, this is a non-destructive migration — meaning the original files remain in place, so nothing breaks during the process.

Once the migration finished, I verified the logs in the Event Log and confirmed everything migrated successfully.

Step 2 – Create a Database Backup

After completing the migration, I immediately took a full database backup of the environment.

This is an important step — it ensures you can safely roll back if anything goes wrong during later steps like field or code migration. I also implemented a short content freeze to prevent users from uploading new files during this phase.

Step 3 – Set Up the Development Environment

Next, I restored the backed-up database in my local environment to mirror the client’s production setup. This allowed me to run all migration scripts safely and test changes before pushing anything live.

Step 4 – Migrate Fields Referencing Media Files

This part required some command-line work. Kentico provides a .NET CLI script that migrates database definitions of fields referencing media files.

All fields of type Media files were updated to the new Pages and Reusable Content data type, and the Media file selector was replaced by the Combined Content Selector.

The best part is — the script is re-runnable, so if any field fails to migrate due to a naming conflict or schema issue, it logs an error and continues safely.

To run the migration, I used:
dotnet run --kxp-migrate-media-file-fields

This step ensures that all database-level references to media files now correctly point to Content Item Assets.

Step 5 – Update the Codebase

Now came the manual part — updating the code to remove references to obsolete APIs.

Here are a few key changes we made:

Old API	New Replacement	Notes
MediaFileInfo	Generated model of content type	The content type must include a content item asset field.
MediaLibraryInfo	ContentFolderInfo	Represents folders inside Content Hub.
IInfoProvider<MediaFileInfo>	IContentItemManager	Used for programmatically managing content items.
AssetSelectorComponent	ContentItemSelectorComponent	Updated UI form component for asset selection.

Some APIs like IMediaFileUrlRetriever and IMediaProtectionService don’t have direct replacements, but we implemented custom logic for asset URLs and resizing where needed.

Step 6 – Deploy Changes

After successfully migrating data and updating the code, we deployed the changes to the client’s environment.

We excluded the temporary MediaLibrariesMigration.MigratedMediaFile content type from the deployment package and ensured the Continuous Deployment restore mode was set to CreateUpdate.

Everything worked as expected on the first deployment — always a good feeling!

Step 7 – Delete Old Media Libraries

Once we verified all assets were functional and no broken links existed, we deleted the original Media Libraries from the environment.

I also updated the Role Management settings to remove permissions for the Media Libraries application, preventing any new legacy libraries from being created accidentally.

Redirects and URLs

Kentico does a great job handling redirects automatically.
All old ~/getmedia/... links are redirected to the new ~/getcontentasset/... URLs.

Important note: direct path URLs like ~/AcmeLibrary/coffee.png don’t get redirected, so we ensured no references relied on those patterns.

Conclusion

Overall, the Media Library to Content Hub migration was straightforward and well-supported.

It’s clear that Kentico is moving towards a modern, flexible, and content-first architecture, and this migration is an important step in that direction.

If you’re still using Media Libraries, I’d strongly recommend starting the migration early. It’s not just about compliance with the July 2026 deadline — it’s also about unlocking a more powerful and scalable way to manage assets.

This migration gave me hands-on experience with Kentico’s latest content architecture, and I must say — it’s a big leap forward for content management in Xperience.

Happy Learning.....See You Soon
Thanks

Building a Super Mario-Style Platformer Game with Amazon Q Developer

Pawan Sharma — Fri, 27 Jun 2025 11:42:37 +0000

⚙️ Amazon Q CLI: AI Right in Your Terminal

To speed up development and minimize context switching, I used the Amazon Q CLI — a command-line interface that brings the power of generative AI right into your local development workflow.

Instead of switching between docs, forums, and editors, I just typed natural language commands directly in my terminal, and Amazon Q responded with intelligent code suggestions, explanations, and fixes.

🧠 What Is Amazon Q CLI?

Amazon Q CLI is a powerful AI tool designed to assist developers via natural language prompts directly from the terminal.

Whether you're building cloud-native applications or something just for fun (like this retro platformer!), Q CLI helps with:

✅ Writing boilerplate code

✅ Generating test cases

✅ Refactoring functions

✅ Explaining unfamiliar code

✅ Looking up AWS documentation

✅ Debugging issues

All without leaving the terminal.

🚀 How I Used It in This Project

Here’s how Amazon Q CLI boosted my workflow while building Super Platform Adventure:

Boilerplate generation: I asked it to create the base structure for the Player, Enemy, and Coin classes — saving me hours of setup.
Physics logic: Instead of manually tweaking jump behavior, I prompted,

“Add gravity and jump velocity logic to player class” — and it just worked.
Bug fixing: When collision detection wasn’t working as expected, I ran:

“Why isn’t sprite collision working in my Pygame project?”

Q diagnosed the problem and suggested using pygame.sprite.spritecollide() properly.
Refactoring: Cleaned up repetitive code using natural prompts like

“Refactor this loop into a method”.

🛠️ Setting Up Amazon Q CLI

Before starting the game, I installed and configured Amazon Q CLI on my system. The setup was quick:

npm install -g @amazon/q-cli
q configure

You’ll be prompted to authenticate with your AWS account, after which you can start prompting away in your terminal.

Amazon Q CLI felt like having a senior dev in the terminal — available 24/7, understanding natural language, and writing code with context.

For game development especially, where quick iteration and frequent debugging are key, this tool saved me countless hours.

So whether you're building a cloud app or just a cool retro game — give Q CLI a try. It’s a game changer. 🎮

Ever dreamed of building your own retro-style platformer? I did — and with the help of Amazon Q Developer, I finally brought that idea to life using Python and Pygame.

Let me walk you through my journey of creating 🍄 Super Platform Adventure, a side-scrolling game inspired by classics like Super Mario, with the power of AI and modern tools.

Amazon Q CLI with prompt

🍄 Super Platform Adventure - Game Prompt

Game Concept

Create a Super Mario-style 2D platformer game using Python and Pygame with the following specifications:

1. Player Character

Appearance: Blue rectangle (40x40 pixels) with simple white dot eyes
Starting Position: (50, 400)
Movement Speed: 5 pixels per frame
Jump Mechanics:
- Jump velocity: -15
- Gravity: +0.8 per frame
- Can only jump on solid ground
Lives: 3
Respawn: Return to start when hit

2. Game World

Size: 800x600
Background: Sky blue (135, 206, 235)
Platforms:
- Ground: full width, height 40px
- Elevated: multiple brown platforms
- Solid collision detection

3. Enemies

Appearance: Red rectangles (30x30), black eyes
Behavior:
- Patrol platforms
- Reverse at edges
- Speed: 2 px/frame
- Not fall off
Combat:
- Jumping = defeat
- Touching = damage
- +100 points

4. Coins

Appearance: Yellow circles (20x20)
Value: 50 points
Behavior: Disappear when collected
Win requirement: All coins must be collected

5. Physics

Constant gravity
Rectangle collision
Platform interaction
Boundary checks

6. Game States

Win: All enemies + all coins
Lose: 0 lives
Active: Real-time physics, score/lives, 60 FPS

7. Controls

Left: A / ←
Right: D / →
Jump: Space / W / ↑
Quit: Window close

8. UI

Score: Top-left
Lives: Below score
Instructions: Bottom
Font: Pygame default, size 36

9. Tech

Pygame
60 FPS
800x600
OOP classes

10. Class Structure

Player: Movement, collision, draw
Enemy: Patrol logic, collision, draw
Coin: Position, collection, draw
Game: Loop, manage objects, collisions, UI

11. Platform Layout

Ground: (0, 560, 800, 40)

Platform 1: (200, 450, 150, 20)

Platform 2: (400, 350, 150, 20)

Platform 3: (600, 250, 150, 20)

Platform 4: (100, 300, 100, 20)

Platform 5: (500, 150, 200, 20)

12. Enemies

(220, 420)
(420, 320)
(620, 220)

13. Coins

(250, 420)
(450, 320)
(650, 220)
(550, 120)
(150, 270)

14. Colors

Player: Blue (0,0,255)
Enemy: Red (255,0,0)
Coin: Yellow (255,255,0)
Platform: Brown (139,69,19)
BG: Sky Blue (135,206,235)
UI: Black (0,0,0)

15. Rules

Collect all coins + defeat all enemies
Touch enemy side = -1 life
Jump on enemy = kill + 100
Coin = +50
Fall = respawn
0 lives = game over

16. Performance

60 FPS
No input lag
Smooth collisions
State transitions

17. Error Handling

Init pygame safely
Handle close
Module exceptions

🎯 Why I Chose This Game

I’ve always loved platformers — nostalgic, challenging, fun.

Perfect for testing:

Physics & collisions
Enemy AI
Scoring & levels

🤖 Prompting with Amazon Q Developer

Started with:

"Build a basic platformer game in Python using Pygame with coins, enemies, and win/loss conditions."

Q Developer impressed me by:

Understanding full context
Creating modular classes
Suggesting gravity and AI logic
Producing working code snippets

Then I kept refining:

“Add scoring system”
“Make enemies patrol”
“Lose life on enemy contact”

Each time: accurate and structured responses 🔥

💡 AI Solutions to Classic Game Dev Problems

Jump Physics

if self.jumping:
    self.vel_y += gravity
    self.rect.y += self.vel_y

Enemy Patrol

if self.rect.left < self.min_x or self.rect.right > self.max_x:
    self.direction *= -1
self.rect.x += self.speed * self.direction

Collisions

pygame.sprite.spritecollide()

⚡ Automation That Saved Time

Amazon Q helped with:

Refactoring
Bug fixing
Full game loop
UI states (restart, win, lose)

Prompted:

"Add restart option when the game is over" — it worked perfectly.

🔧 Game Features Summary

Physics + gravity
Coins + enemies
Score & lives
Win/Lose logic
Expandable design

🐍 Code Snapshot

class Player(pygame.sprite.Sprite):
    def __init__(self):
        self.speed = 5
        self.jump_power = -15
        self.lives = 3
        # Setup player sprite & controls

Full Source Code:

📦 GitHub Repository

🎮 Try the Game

pip install pygame
python super_game.py

🙌 Credits

Game dev with 💖 using Python + Pygame
AI prompts powered by Amazon Q Developer
Code hosted on GitHub

A robust solution for managing and resolving conflicts in NuGet package dependencies within Visual Studio

Pawan Sharma — Thu, 11 Apr 2024 17:29:28 +0000

Today I got a project in .net core for upgrading the version from .net 6 to 8 and I was super excited but when I set up the project on my system, I found the complexity of the project.

There are 8-10 projects and references to each other’s. I started to work on upgradation. I was happy because I had done my job (.Net 6 to 8) but when I built the project then lots of errors are there regarding conflicts of dependencies,

So, I started to resolve it one by one but when I built the project again then errors of conflict increased more. I spent much more time to resolve the issues but not succeed then I found NuGetSolver to resolve this issue. I downloaded the extension from VS Marketplace. NuGetSolver is a powerful Visual Studio extension designed to help you tackle NuGet dependency conflicts with ease.

I run the tool from the “Solution Explorer” by right-clicking and selecting “Resolve Dependency Conflicts”.

You can run the tool even if your solution doesn’t have any dependency conflicts at the moment. It will upgrade your dependencies while keeping the changes minimal.

Thanks, See you in next blog.