Workshop: Rules and commands for Agentic IDE (Cursor, Claude, Copilot)

Create effective rules and commands for modern Agentic IDEs (Cursor, Claude, Copilot) and start systematically managing agents.

Mentor - Viacheslav Koldovskyy, Competence Manager at SoftServe

Buy ticket

Tickets cost 3 600 UAH

Buy ticket Buy ticket

Buy ticket

Learn to create effective rules and commands for modern Agentic IDEs (Cursor, Claude, Copilot) and stop "just prompting" - start systematically managing agents. In two intensive sessions you will learn how to design rules for teams/projects, build a library of commands, configure safe "rails" for agents and get stable results from AI tools in real projects.

Content upgrade: we are adding Agent Skills – the newest and most practical tool for Agentic IDE today. We will build not just prompts, but a Rules + Commands + Skills system that can be scaled to teams and projects.

In two practical sessions, you will:

Understand how an agent IDE thinks:
- what are the types of prompts and rules (system, project, file-level, codebase rules);
- how do they affect the quality, cost and stability of the result;
- what are the typical mistakes when working with rules and commands
Learn how to work with rules and commands in different tools, and what are the features for each tool (Cursor, Claude Code, GitHub Copilot).
Learn to build a framework of rules for a project:
- how to get a set of stable rules from requirements (PRD / tasks / user stories);
- how to formalize what is usually "in the head of the senior";
- how to use rules to teach the IDE to understand new versions of libraries and frameworks.
Learn to solve typical cases and scenarios using rules and commands:
- scenarios for typical tasks (feature, bug fix, refactoring, performance, security)
- team templates for different roles: Dev, QA, DevOps, TL.
Understand approaches to security and quality:
- how to reduce hallucinations and "self-activity" of the agent due to rules
- how to describe license restrictions, quality standards and code style
- how to embed checks (tests, linters, review rules) into command instructions.
- Patterns for working with rules (Memory Bank, etc.).
You will work through a practical agent management cycle:
set a task → apply rules and command → get code → validate → fix the improved rule.

Workshop outcome:

Practical skills in working with rules and commands in Cursor, Claude, Copilot.
Ready-made instruction templates for individual work and for the team (separate roles of Dev, QA, DevOps, tech lead, architect).
A framework for building rules for the project - from requirements and constraints to a clear set of instructions for agents.
Understanding how to standardize work with AI tools in the team: so that the result is stable, reproducible and transparent in terms of costs.
A clear idea of when "manual prompting" is enough and when it is worth moving to a full-fledged system of rules and commands.

Format:

Materials: Video recording of the workshop (5 hours) and a presentation with a selection of materials

Language of the event: Ukrainian

After purchasing a ticket, refresh the page and you will see the video recording and all materials.

Language of the presentation: Ukrainian/English

Who will be interested?

Developers of all levels and tech leads/architects, DevOps/SREs who want to stop “inventing prompts from scratch every time” and make interaction with agents predictable.
Product/Project Managers, BAs, designers and other non-technical specialists – for prototyping and creating solutions independently without the participation of developers
QA/Automation – for describing validation rules, test generation and standardization of quality approaches.
Mentors, team leads and Engineering Management specialists who build standards for working with AI tools in teams and companies.

Program

Session 1: Theory of Rules and Commands for Agentic IDE

Introduction: how “just prompting” differs from a structured system of rules and commands.
Types of instructions in Agentic IDEs:
- system-level, project-level, and hierarchical rules
- rules by role (Dev, QA, Reviewer, Architect)
Tool overview (Cursor, Claude Code, GitHub Copilot) and their features.
How to turn requirements and constraints into rules:
- business constraints, security, licensing
- quality standards, architectural principles, code style
Common mistakes and anti-patterns:
- rules that are too long or contradictory
- rules that are technically infeasible
- “magical” prompts without clear success criteria
Q&A

Session 2: Practice — Building a System of Rules and Commands

Preparing your IDE to work with rules:
- key IDE settings
- optimal project structure for efficient agent collaboration
Practical case study:
- start with a simple PRD or set of requirements
- define a rule set (quality, security, style, architecture)
- create a command/script library for common tasks
Working with multiple tools (Cursor, GitHub Copilot, Claude Code) and their specific characteristics.
Completing the agent workflow:
- assigning a task → launching the command → receiving code
- validating results (tests, reviews, checks)
- updating rules and commands — how to evolve rule systems
Checklist for participants:
- minimal set of rules for starting a new project
- structure of internal documentation with team rules
- how to onboard new developers with the rule system
Q&A

The course concept and all course materials are the intellectual property of FVDAYS. Copying of course content and materials is possible only with the consent of FWDAYS.