Video summary

Как ИИ меняет разработку в 2026: главные инсайды с крупнейших IT-конференций / Кирилл Мокевнин

Main summary

Key takeaways

Technology

Overview

Kirill Makevнин (Organized Programming podcast) shares “behind-the-scenes” insights from multiple IT conferences on how agent-based AI (“Ишко / Ishka”, MCP/skills/agents) is being integrated into software development and company processes through 2026.

He emphasizes that real adoption in production code is still limited. The biggest bottlenecks often shift from “writing code” to review, process, and rollout.

Conference / community context & education updates (product/guide angle)

  • He’s been speaking at many events (e.g., Harlowd, Teamlit Conf, DEFC/agent-coding talk).
  • He mentions a dense offline workshop format focused on teaching people to work with Ishka.
  • His C programming course (Hexlet) runs in multiple streams, and he updates materials to include more advanced agent-based development.
  • He invites to a large tent-based event on the Volga (“NoCamp” in his later callout).
  • He references:
    • Hexlet Club (closed community)
    • C Level Club group workshops focused on introducing Ishka
  • He also discusses “skills 2026” issues (see below).

Key technological adoption insight: how much people actually code with agents

  • At his events, only ~20% of attendees claim to write code entirely using agents (likely less in broader audiences).
  • Why full agent autonomy is rare in large organizations:
    • Code ownership and security/privacy constraints.
    • In banks, companies often build closed internal environments, sometimes using internal model stacks instead of public tooling.

Corporate “agent stack” patterns (features / architectures)

A common internal structure he describes:

  • Adding MCPs, “skills”, and tooling around a base model (he mentions “GLM… other models” as internal alternatives).

  • Integrating an agent coding assistant plus plugins (e.g., a “CS-code plugin” is mentioned).

  • He contrasts internal assistants vs best external models:

    • Internal setups are generally weaker than top external models (he compares internal quality to “Claude”).

  • Some companies handle limitations by forking open tools:

    • Example: Yandex forked OpenCD (or a similar project) to improve internal capability.

Reality check on “replacing developers”

Even where agents are used:

  • Fully autonomous coding is uncommon.
  • Developers still need to guide agents heavily and maintain practices like code review.
  • He places the “real revolution” around Oct/Nov of the previous year, when Ishka + supporting tooling became capable enough to matter.

What companies are optimizing first: “AI from the DLC”

He repeatedly frames the practical focus as improving end-to-end productivity of contributors using:

  • Skills + project context changes
  • Rules/workflows + MCP integration

However, he stresses:

  • Training and correct usage are inconsistent.
  • Tools can be misused.
  • Global transformation is uncertain—companies want AI, but “how” remains unclear.

Will AI radically change development processes?

Skeptical view:

  • He expects more visible improvements in documentation, since updates are easier when content can change independently.
  • But he argues the main bottlenecks are usually not “coding speed”; they’re in process complexity, especially in large orgs:
    • training people
    • rollout
    • changing instructions and compliance procedures

He compares this to DevOps: initial goals were simplification, but the outcome created new complexity and roles.

AI impact outside coding (automation examples)

He suggests business process changes are easier than development process changes:

  • Mentions robotic call centers (e.g., Sberbank).
  • Describes voice/text assistants that complete tasks, such as updating passport data via chat.

Conclusion: roles in support and similar functions may shrink faster than dev roles.

HR / staffing expectations (analysis)

  • He reports many companies claim they want to reduce staff by up to 30% to increase productivity.
  • Typical loop he describes:
    • Hiring slows due to economics.
    • AI enables more coverage without new hiring.
    • Eventually productivity evens out across companies, and hiring resumes unless macro conditions change.

DevOps & reproducibility risk: direct command execution

A detailed concern:

  • If an agent can issue commands that bypass IaC pipelines (Terraform/Helm charts), developers may start doing “do one, do two…” directly.
  • DevOps worries:
    • non-reproducible changes
    • drift/inconsistency
    • hard-to-audit operations

Likely outcome (his guess): access will be restricted to safer pathways, while agents remain useful mainly for analysis/logging rather than production actions.

Review process becomes the new bottleneck (quality/safety)

He argues that as agents generate more code (sometimes “10x”):

  • Review workload can become even harder.
  • Semi-automated review still can’t fully replace human validation of corner cases and compliance.
  • Teams using Ishka on high-stakes data (example: VK platform team) keep strict controls:
    • expensive mistakes prevent “freeform” action.

Token usage metrics: KPI vs training phase

He discusses how token consumption is treated:

  • Some companies use token usage as a proxy for inefficiency.
  • Others (example: Ber team) treat token-heavy usage as acceptable during training/onboarding:
    • allow experimentation first
    • later identify and coach the users consuming the most resources

So “token consumerism” is framed more as a learning mechanism than a strict efficiency KPI.

Spec-Driven Development and knowledge-base approach (tutorial/guide content)

He emphasizes “Spec Driven Development” and related standards:

  • Companies build pipelines where docs/specs are generated, cross-checked, and used across teams (including designers).
  • Where earlier skepticism existed, practical adoption improved:
    • Instead of writing tons of documents manually, agents + skills can maintain a living knowledge base.

He mentions open standards/approaches:

  • Open Spec: storing requirements/context/invariants across multiple files.
  • OpenAPI and generators for predictable code.

He also highlights a skills/tool ecosystem (Grillm/Mat referenced):

  • Skills can auto-poll/update docs after each agent session.
  • Result: project requirements and structure evolve continuously without manual spec reading.

“Skills 2026” problem: custom skills rarely get reused

A practical failure mode he covers:

  • Many companies create huge numbers of internal skills.
  • Reuse is low because validating/keeping skills consistent with each project is painful.

Suggested approach:

  • Make the project “native” for the agent’s capabilities rather than forcing the agent to “understand” every custom architecture.

He warns against “building everything yourself” even if agents can generate code:

  • custom solutions increase maintenance and context clutter
  • risk of exponential codebase complexity without sufficient documentation

How to interact with the agent during refactoring/onboarding

Process guidance:

  • Don’t immediately instruct “how to solve”; use open questions and conversations.
  • Modern models can infer solutions from the problem’s essence.
  • Over-prescribing steps can block better alternatives.

When terminology mismatches:

  • sometimes you must patch project-specific terms or describe exceptions directly (e.g., course naming changes, “kursme” vs “enrollment” terminology).

Example automation flow: generators + teach “don’t edit generated code”

A proposed workflow for agent coding with generated artifacts:

  • Maintain generator chains:
    • edit source → run generator → output code
  • Teach the agent that certain files are generated and should not be edited directly.
  • Over time, editing becomes mostly declarative/predictable rather than manual.

Main speakers / sources (as stated in the subtitles)

  • Kirill Mokevin / Кирилл Мокевнин — main speaker (host of Organized Programming podcast)
  • Oleg Bunin — mentioned as organizer/creator of a conference format (“DEFC…”)
  • Kirill Minshov / Кирилл Миншов — Vice President at Sberbank, speaker (story about 10x teams and transformation obstacles)
  • “Mat” / Grillm — referenced as an author of a documentation/skills system (tools/skills with a large repo popularity)

Original video