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:

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):

/plugin marketplace add burakdmir/abp-skills

/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