How I built 23 AI agent skills covering every aspect of ABP Framework v10.x (10.4–10.6) — and why it matters for the future of .NET development.

🔗 GitHub: github.com/burakdmir/abp-skills

The Problem

AI coding assistants like Claude Code and OpenCode are transforming how we write software. But they have a fundamental limitation: they don't know your framework.

When you ask an AI agent to "create a new application service in ABP," it might generate something that looks reasonable but misses critical ABP patterns:

• No ApplicationService base class inheritance
• Missing [Authorize] permission checks
• Direct DbContext access instead of IRepository
• No UOW attribute
• Manual DTO mapping instead of using the configured object mapper
• Ignoring localization, validation, and exception handling conventions

The result? Code that compiles but doesn't follow ABP best practices — and requires significant manual correction.

The Solution: AI Agent Skills

AI agents support skills — structured knowledge files that teach them specific frameworks, patterns, and conventions. When a skill is active, the AI's responses are grounded in real framework documentation instead of generic patterns.

I built abp-skills — a collection of 46 skill files (23 topics × 2 AI tools) covering every major aspect of ABP Framework v10.x (10.4–10.6).

GitHub Repository: github.com/burakdmir/abp-skills

What's Included

The repository covers 23 ABP topics, each with two versions:

| # | Topic | What It Covers | |---|---|---| | 1 | Framework | Getting started, solution templates, project structure | | 2 | DDD | Entities, aggregates, repositories, app services, DTOs, UOW, specifications | | 3 | Modularity | Module system, DependsOn, lifecycle, plugin modules, modular monolith | | 4 | EF Core | DbContext, repositories, migrations, PostgreSQL/MySQL/SQLite/Oracle | | 5 | MongoDB | MongoDbContext, collections, indexes, transactions, replica set | | 6 | Multi-Tenancy | Tenant resolvers, ICurrentTenant, IMultiTenant, database isolation | | 7 | CLI | ABP CLI commands, new, add-package, build, new-package | | 8 | UI | MVC/Razor Pages, Blazor, Angular, React, UI components | | 9 | Infrastructure | Event Bus, Background Jobs, Caching, Redis, BLOB, Emailing, SignalR | | 10 | API | API controllers, dynamic proxies, Swagger, versioning, dynamic clients | | 11 | Authorization | Permission system, permission groups, resource-based auth, policies | | 12 | Validation | DTO validation, Data Annotations, FluentValidation, IValidatableObject | | 13 | Exception Handling | Error handling, RemoteServiceErrorResponse, HTTP status mapping | | 14 | Localization | Localization resources, JSON files, culture fallback, L[] helper | | 15 | Settings & Features | ISettingProvider, ISettingManager, IFeatureChecker, feature toggles | | 16 | Audit Logging | Audit logging, entity history, AbpAuditingOptions, IAuditingStore | | 17 | Dependency Injection | DI, ITransientDependency, [Dependency], [ExposeServices], LazyServiceProvider, Autofac | | 18 | Testing | Integration tests, *TestBase, SQLite in-memory, Shouldly, NSubstitute, data seeding | | 19 | Microservices | Solution structure, Integration Services, distributed events (RabbitMQ), YARP gateway, OpenIddict | | 20 | Object Mapping | IObjectMapper, Mapperly (default), AutoMapper profiles, entity↔DTO mapping | | 21 | Development Flow | End-to-end entity flow: domain → migration → contracts → service → permission → test | | 22 | Dependency Rules | Layer dependency direction, project reference matrix, architecture anti-patterns | | 23 | Deployment | Clustered/stateless, distributed cache/lock, forwarded headers, SSL, OpenIddict prod, Docker/Helm |

Each topic has:

• Claude Code version — Detailed (~210–850 lines) with full explanations, patterns, and best practices
• OpenCode version — Compact (~55–230 lines) as quick-reference for inline use

How It Works

Skill Activation

Each skill file defines a Trigger section — keywords that tell the AI when to activate it:

## Trigger
- "ABP authorization"
- "ABP permission"
- "ABP role"
- "ABP policy"

When you mention any of these terms, the AI loads the full skill content and grounds its response in ABP-specific patterns.

Example: Before vs After

Without the skill:

// AI generates generic code
public class BookService
{
    private readonly AppDbContext _db;
    public async Task<Book> Create(Book book)
    {
        _db.Books.Add(book);
        await _db.SaveChangesAsync();
        return book;
    }
}

With the ABP Authorization skill active:

// AI generates ABP-conformant code
public class BookAppService : ApplicationService, IBookAppService
{
    private readonly IRepository<Book, Guid> _bookRepository;

    public BookAppService(IRepository<Book, Guid> bookRepository)
    {
        _bookRepository = bookRepository;
    }

    [Authorize("BookStore_Books_Create")]
    public async Task<BookDto> CreateAsync(CreateBookDto input)
    {
        var book = ObjectMapper.Map<CreateBookDto, Book>(input);
        return ObjectMapper.Map<Book, BookDto>(
            await _bookRepository.InsertAsync(book, autoSave: true)
        );
    }
}

The difference is night and day: proper base class, repository abstraction, permission check, object mapping, and UOW handling — all automatically.

Installation

Claude Code Plugin — ABP Sensei (recommended)

The claude/ skills ship as a first-class Claude Code plugin named abp-sensei, distributed through this repo's plugin marketplace. One install gives you all 23 skills, an abp-expert subagent (a senior ABP v10.x architect that detects your solution's ABP version), and slash commands (new-entity, crud, review, upgrade-audit, explain):

# 1. Add this repo as a plugin marketplace
/plugin marketplace add burakdmir/abp-skills

# 2. Install the plugin
/plugin install abp-sensei@abp-skills

New versions ship on every push to main; pull them with /plugin marketplace update abp-skills (or opt into autoUpdate in settings.json).

Claude Code (manual clone)

git clone https://github.com/burakdmir/abp-skills.git ~/.claude/skills/abp-skills

OpenCode

git clone https://github.com/burakdmir/abp-skills.git ~/.config/opencode/skills/abp-skills

Per-Project

Drop individual skill directories into your project's .claude/skills/ or .opencode/skills/ folder.

Real-World Impact

Here's what changes when AI agents have ABP skills:

1. Faster Development Cycles

No more explaining ABP conventions to the AI. It already knows that:

• Application services inherit from ApplicationService
• Repositories use IRepository<TEntity, TKey>
• Permissions are defined via PermissionDefinitionProvider
• Settings use ISettingProvider with a fallback chain

2. Consistent Code Quality

Every generated snippet follows ABP patterns:

• Proper DDD layer separation
• Correct dependency injection conventions
• Standard exception handling and validation
• Localization-ready code structure

3. Reduced Review Time

Code generated with skills active requires less manual correction because:

• It uses the right base classes and interfaces
• It includes authorization checks
• It follows the options pattern for configuration
• It respects multi-tenancy boundaries

4. Onboarding Acceleration

New team members can use AI agents as ABP tutors:

• "How do I create a new module in ABP?"
• "What's the difference between ISettingProvider and ISettingManager?"
• "How does the distributed event bus work?"

The AI answers with ABP-specific examples, not generic .NET patterns.

Behind the Scenes

Methodology

Every skill file is built from official ABP Framework v10.x documentation (10.4 baseline + the 10.5 migration guide). I reviewed:

• 36 module documentation files
• 8 framework subdirectories (api-development, architecture, data, fundamentals, infrastructure, real-time, ui)
• 7 tutorials (book-store, todo, modular-crm, microservice, mobile)
• 6 solution templates (single-layer, layered, microservice, MAUI, WPF, console, empty)
• 10 get-started guides

Design Decisions

Two versions per topic: Claude Code benefits from detailed explanations (the model has a large context window), while OpenCode's architecture prefers compact quick-reference files.

Trigger-based activation: Skills should activate naturally when the user mentions relevant topics — no manual loading required.

Production-ready examples: Every code snippet is copy-paste ready and follows ABP conventions exactly.

Cross-references: Skills link to each other and to official ABP docs for deeper exploration.

Contributing

The repository is open source under the MIT License. Contributions are welcome:

• New skills: Missing a topic? Open a skill request issue
• Updates: Found outdated information? Submit a PR
• Bug reports: Incorrect code examples? File a bug report

See CONTRIBUTING.md for guidelines.

What's Next

The first 17 topics have since grown to 23 — Testing, Microservices, Object Mapping, Development Flow, Dependency Rules, and Deployment all shipped. The ABP ecosystem keeps evolving, so planned additions include:

• ABP Studio integration skills for AI-assisted development workflows
• LeptonX theme customization skills
• Module-specific skills for Identity, Saas, CMS Kit, and other pre-built modules
• More slash commands for the ABP Sensei plugin

Conclusion

AI coding agents are only as good as the context they have. By providing structured, framework-specific knowledge through skill files, we can transform generic AI output into production-quality ABP code.

This repository is a starting point — a proof that framework-specific AI skills work, and a foundation for the community to build upon.

Star the repo, contribute, and let's make AI-assisted ABP development the norm, not the exception.

🔗 GitHub: github.com/burakdmir/abp-skills

Burak Demir — .NET Developer & ABP Framework Enthusiast

So, you've just upgraded your ABP Framework application to a newer version (like v9.2.0+) and suddenly, your application can't read data from its MongoDB database. You're seeing strange deserialization errors, especially related to Guid types. What's going on?

You've likely run into a classic compatibility issue with the MongoDB .NET driver.

The Problem: Legacy vs. Standard GUIDs

Here's the short version:

• Old MongoDB Drivers (used in older ABP versions) stored Guid values in a format called CSharpLegacy.
• New MongoDB Drivers (v3.0+), now default to a universal Standard format.

When your newly upgraded app tries to read old data, the new driver expects the Standard format but finds CSharpLegacy. The byte orders don't match, and... boom. Deserialization fails.

The ABP Framework team has an excellent official guide covering this topic in detail. We highly recommend reading their MongoDB Driver 2 to 3 Migration Guide for a full understanding.

Our tip below serves as a fast, application-level fix if you need to get your system back online quickly without performing a full data migration.

The Quick Fix: Tell the Driver to Use the Old Format

Instead of changing your data, you can simply tell the new driver to continue using the old CSharpLegacy format for all Guid and Guid? properties. This provides immediate backward compatibility without touching your database.

It’s a simple, two-step process.

Step 1: Create a Custom Convention

First, create this class in your .MongoDb project. It tells the serializer how to handle Guid types.

using MongoDB.Bson;
using MongoDB.Bson.Serialization;
using MongoDB.Bson.Serialization.Conventions;
using MongoDB.Bson.Serialization.Serializers;
using System;

public class LegacyGuidConvention : ConventionBase, IMemberMapConvention
{
    public void Apply(BsonMemberMap memberMap)
    {
        if (memberMap.MemberType == typeof(Guid))
        {
            memberMap.SetSerializer(new GuidSerializer(GuidRepresentation.CSharpLegacy));
        }
        else if (memberMap.MemberType == typeof(Guid?))
        {
            var guidSerializer = new GuidSerializer(GuidRepresentation.CSharpLegacy);
            var nullableGuidSerializer = new NullableSerializer<Guid>(guidSerializer);
            memberMap.SetSerializer(nullableGuidSerializer);
        }
    }
}

Step 2: Register the Convention at Startup

Now, register this convention in your YourProjectMongoDbModule.cs file. Add this code to the top of the ConfigureServices method. This ensures your rule is applied globally as soon as the application starts.

using Volo.Abp.Modularity;
using MongoDB.Bson.Serialization;
using MongoDB.Bson.Serialization.Conventions;

public class YourProjectMongoDbModule : AbpModule
{
    public override void ConfigureServices(ServiceConfigurationContext context)
    {
        // Fix Start
        var conventionPack = new ConventionPack { new LegacyGuidConvention() };
        ConventionRegistry.Register(
            "LegacyGuidConvention",
            conventionPack,
            t => true); // Apply to all types
        // Fix End

        // ... Your existing ConfigureServices code
    }
}

An Alternative to Full Data Migration

It's important to note that the method described here is an application-level fix. It's a fantastic alternative to performing a full data migration, which involves writing scripts to convert every legacy GUID in your database.

If you are interested in the more permanent, data-centric approach, the ABP.IO community has a detailed guide on Migrating MongoDB GUIDs from Legacy to Standard Format.

Our quick fix is ideal for getting a system back online fast or when a database migration is too complex. The full migration is better for long-term standards compliance. Choose the path that best fits your project's needs!

That's It!

Restart your application, and the errors should be gone. Your app can now correctly read its old Guid data, and it will continue to write new data in the same legacy format, ensuring consistency.

This approach is a lifesaver for existing projects, saving you from a risky and time-consuming data migration. For brand-new projects, you might consider starting with the Standard representation, but for everything else, this is a clean and effective fix. Happy coding!