Как использовать AI разработчику в 2027 / Полный курс по AI в 6 часах

Summary

The video presents AI as a practical tool for software development, not a replacement for engineering judgment. Its central argument is that developers should choose tools according to the task, provide enough project context, and verify the results. AI can speed up routine work, but it can also produce convincing errors, miss business requirements, or multiply problems in a codebase if its output is accepted blindly.

1. Three kinds of AI tools

The course distinguishes between models and the tools built around them. It groups developer AI tools into three broad categories:

• Chat assistants—such as ChatGPT, Claude, Gemini, Perplexity, and DeepSeek—are suited to explanations, learning, brainstorming, and research.
• IDE agents—such as Cursor, Windsurf, and GitHub Copilot—work inside a project and can use its files, imports, types, and dependencies as context.
• Autonomous coding agents—such as Claude Code, OpenCode, and Codex—can take on larger tasks, edit multiple files, run terminal commands and tests, and then report back. They can work faster with less step-by-step supervision, but their results require a capable review.

The recommended selection order is task → tool category → specific tool, rather than choosing a favorite model first. Experienced developers may use several tools in parallel because no single product is best for every job.

2. How the course compares the major assistants

The presenters describe different strengths among the products. These are the course’s assessments, not guarantees:

• ChatGPT: Broad ecosystem, learning resources, integrations, and reusable custom assistants.
• Claude: Code-related work, structured analysis, documentation, and longer reasoning tasks; Claude Code can work locally in a terminal.
• Gemini: Large-context analysis and integration with Google products such as Docs, Gmail, and Sheets.
• Perplexity: Search with citations and source checking, including research into current libraries or technologies.
• DeepSeek: A low-cost or free option for everyday tasks, with open models that can be run locally. The presenters caution that local models are less capable for complex agent workflows.

The video also discusses model modes, context windows, product plans, and subscriptions. These details—including model names, prices, limits, and capabilities—are time-sensitive, and some auto-generated subtitle details may be inaccurate.

3. Prompting and context

The course explains that language models generate likely continuations from the text and context they receive. In practical terms, a vague request tends to produce a generic answer; precise requirements make a useful result more likely.

Recommended prompt context includes:

• The task and expected outcome.
• The language, framework, libraries, and relevant project files.
• Existing architecture and conventions.
• Constraints, invariants, and edge cases.
• What the AI should not change.

The advice is to work iteratively: request a plan or analysis first for complex tasks, inspect a draft, then refine it. Use separate chats for unrelated work so stale context does not contaminate a new task. The course also distinguishes a model’s total context window from the smaller amount of context it can use effectively for focused reasoning.

4. Backend development

The backend chapter emphasizes that AI works well with text-heavy development workflows: code, logs, stack traces, SQL, and test output. It can help generate endpoints, migrations, queries, tests, documentation, and routine code—but a developer still needs to check the implementation against project requirements.

Key practices include:

• Give the agent access to useful feedback loops: compilation, linters, tests, logs, and API or database checks.
• Write tests for expected behavior and failure cases. Tests should fail against an incorrect or empty implementation and pass after the fix; green tests that do not check the intended behavior offer little protection.
• Pay special attention to cases AI may miss, including idempotency, repeated webhooks, race conditions, N+1 queries, missing indexes, locks, and security issues.
• Review generated SQL and code for performance and correctness rather than assuming the model can infer production workload or business intent.
• Use documentation sources or MCP tools—such as the discussed Context7 integration—to reduce errors involving changed or unfamiliar APIs.
• Avoid blind copying: ask the agent to explain decisions when that will help the developer understand the implementation.

The chapter also covers privacy and security. Keep secrets out of prompts and repositories, use permissions rather than relying only on instructions not to modify sensitive resources, and follow company policy on cloud models and local tools. The presenters caution that local models may be unsuitable for complex agentic coding, even if they can handle simpler tasks.

5. Frontend development

The frontend section identifies useful applications such as generating boilerplate, TypeScript types, forms, API clients, mock data, tests, and documentation. AI can also help refactor large components, explain unfamiliar code, trace project structure, and suggest test cases.

Its suggested workflow is to discuss a feature before asking for code:

1. Describe the stack and requirements.
2. Ask for an architecture or implementation approach.
3. Identify edge cases and likely problems.
4. Generate a basic implementation.
5. Review it for typing, rendering, performance, architecture, and missing scenarios.

AI can help a developer get oriented in an unfamiliar project, but it may misunderstand business logic or project conventions and can invent APIs or use outdated approaches. Generated code and tests therefore need human review.

6. Mobile development and agent workflows

The mobile chapter describes three levels of AI use:

1. Chat-assisted prototyping and coding: The developer stays close to the code and reviews each result.
2. A coding agent: The agent works with the project, guided by project-specific instructions and skills.
3. A multi-agent workflow: An orchestrator delegates analysis, architecture, implementation, testing, and verification to subagents.

For agent-based work, the presenter recommends maintaining project guidance files covering architecture, code style, tests, design systems, backend integration, and related conventions. Figma and Git hosting integrations can provide additional context. Large features should be broken into manageable units or chats; the course warns that multi-agent setups consume more tokens and can reduce developer control.

The mobile workflow also includes requirements analysis, team grooming, decomposition, implementation, testing, and release considerations. AI can assist with meeting transcription, initial task breakdown, boilerplate, tests, and debugging, but the speaker advises against relying on it for deterministic manual testing.

7. QA, reviews, and demonstrations

The QA segment argues that AI can substantially accelerate repetitive test maintenance, but insists on reviewing the changes and running the tests. One example claims that refactoring Allure steps across roughly 1,500 automated tests, previously estimated at a month, could be done in about two hours with an agent. The presenter says they still checked the test run, reviewed diffs, and sampled tests before accepting the changes.

A shorter Cursor demonstration uses plan mode to update Allure annotations in a 32-test educational project. The presenter reviews the agent’s plan and additional proposed changes rather than accepting them automatically. The supplied subtitles end during this demonstration.

The course also recommends conducting code reviews in a fresh, independent session: provide the task, relevant documentation, and a code diff, but avoid biasing the reviewer with the implementation agent’s reasoning. AI can help identify likely defects, security concerns, and missed cases; human review remains important, especially for critical systems.

Guides, tutorials, and exercises included

• Tool-selection guide: Choose among chat assistants, IDE agents, and autonomous agents based on the task.
• Prompting tutorial: Provide project context, constraints, and a specific expected result; work iteratively.
• Backend tutorial: Use tests, logs, build checks, database/API tools, and documentation sources as a feedback loop.
• Test-writing exercise: Write tests first, include failure cases such as repeated discount or webhook requests, confirm they fail against the incomplete implementation, then implement the behavior.
• Frontend exercise: Choose a component and ask AI to explain it, identify potential problems, propose a refactoring plan without code, and conduct a review; assess which recommendations are sound.
• Mobile agent guide: Prepare project-specific instructions and, for larger workflows, delegate defined roles to subagents.
• QA demonstration: Use Cursor to plan and apply Allure test annotations, then verify the plan, diff, and test results.

Main speakers and sources

• Vadim — Frontend mentor and founder of Frontend Mountain; introduces the general framework for AI tools and prompting.
• Artem Romanovich — Go/backend developer and mentor; covers backend workflows, testing, databases, MCP, and code review.
• David — Frontend mentor and practicing developer; covers frontend use cases, reviews, and the hiring market.
• Anton — Android mentor; discusses mobile development and single-agent and multi-agent workflows.
• Coconut QA — Senior Python QA specialist and mentor; demonstrates AI-assisted test maintenance and Allure annotations.
• Course host/source: The video is published on the Антон Назаров | Осознанная Меркантильность channel.