Training: AI Tools Supporting Developers

Day 1 (8h) – Effective work with AI: from the basics to working code

Module 1: Introduction to AI in a developer’s work (2h)

• Generative AI and language models: how they work and which programming tasks they can help with.
• AI assistant, agent and workflow: the difference between talking to a model and delegating work with code to it.
• Core concepts: prompt, tokens, context window, tool calling and project instructions.
• A map of the tools: ChatGPT, Codex, GitHub Copilot, Claude Code and Cursor, and where each of them fits into everyday work.
• Introduction to MCP, RAG and skills: access to tools, use of project knowledge and reusable procedures.
• Limitations of AI and rules for working with company code: verifying answers, protecting data and taking responsibility for changes.

Module 2: Requirements, context and skills: how to prepare AI to work with your project (3h)

• Preparing a task for AI: goal, technical context, constraints, acceptance criteria and the way the result is checked.
• Analysing an existing repository: entry points, dependencies, data flow and the places that need to change.
• Translating a feature description into an implementation plan, a list of files and test scenarios.
• Project instructions: architecture, code conventions, test commands and rules for working with the repository.
• Skills as reusable working procedures: where they apply, instructions, supporting materials and the expected result; how they differ from a single prompt and from permanent project rules.
• Workshop: preparing a feature specification and a first skill for planning changes in line with project standards.

Module 3: GitHub Copilot and Cursor: implementing a feature in the IDE (3h)

• Setting up the environment and pointing to context: files, symbols, documentation and project rules.
• Working with an assistant and an agent: explaining code, planning a solution and making changes across multiple files.
• Implementing a feature in line with the existing architecture, interfaces and team conventions.
• Generating and running tests: happy paths, edge cases and error handling.
• Controlling changes: reviewing diffs, spotting unnecessary modifications and rolling back proposals that miss the mark.
• Workshop: delivering a feature together with tests and assessing it against the acceptance criteria.

Day 2 (8h) – Agentic work with a repository, skills and integrations via MCP

Module 4: Claude Code and Codex: from analysing a bug to a verified fix (2h)

• Preparing an agent to work with a repository: project instructions, available tools and the scope of permissions.
• Planning multi-file changes and identifying the points that require a developer’s decision.
• Diagnosing bugs from code, logs, terminal messages and test results.
• Creating a bug-fixing skill: reproducing the problem, a regression test, a minimal fix and verification.
• Working on a separate Git branch: controlling the scope of changes, reviewing results and preparing a pull request description.
• Workshop: using a skill to diagnose a bug, prepare a regression test and deliver a fix.

Module 5: MCP in practice: connecting agents to tools and data (3h)

• Model Context Protocol: the role of the client and the server, and exposing tools, resources and prompt templates.
• Choosing the right integration for the task: a GitHub repository, issues, technical documentation and test environment data.
• Connecting a ready-made MCP server to a coding assistant and checking the operations it exposes.
• Tool calling by the model: input parameters, interpreting results and handling integration errors.
• Access control: read-only permissions, protecting tokens and approving operations that change data.
• Workshop: fetching the content of an issue through MCP and preparing a change plan tied to the code of the project.

Module 6: Testing, refactoring and code review supported by AI (3h)

• Designing tests from requirements: finding missing scenarios and avoiding tests that repeat the mistakes of the implementation.
• Refactoring under the protection of tests: simplifying functions, removing duplication and separating responsibilities.
• Preparing a code review skill: evaluation criteria, severity levels for comments, pointing to evidence in the code and the report format.
• Verifying an agent’s comments: telling real problems from false alarms.
• Prompt injection in files, skills, issues and tool output: recognising attempts to change an agent’s instructions.
• Workshop: reviewing a pull request with a skill, improving the code and confirming it works with tests.

Day 3 (8h) – RAG and your own agent supporting work with code

Module 7: RAG: an assistant that uses project documentation (4h)

• Retrieval-Augmented Generation: searching for knowledge and adding it to the context of the model’s answer.
• Choosing an approach: when text search or IDE context is enough, and when RAG is worth applying.
• Building a knowledge base from the README, API documentation and architectural decisions: splitting content, metadata and keeping sources current.
• Embeddings and semantic search: finding the passages that answer a developer’s question.
• Verifying quality: relevance of the retrieved passages, citing sources and answering when the information is missing.
• Workshop: running, on a prepared skeleton, an assistant that answers questions about the project based on its documentation.

Module 8: Building a simple agent for working with code (4h)

• Designing an agent: goal, instructions, tools, task state and the conditions for finishing work.
• Tool calling in practice: defining tool parameters, validating calls and passing results back to the model.
• Exposing controlled operations: reading files, searching documentation, preparing a fix and running selected tests.
• Combining RAG, MCP and skills: project knowledge, access to tools and procedures for carrying out tasks.
• Limiting autonomy: allowed paths and commands, limits on steps and cost, and human approval of changes.
• Workshop: extending the agent skeleton so that it analyses an issue, proposes a fix and reports test results.