ИИ-помощники в программировании ворвались в повседневную жизнь разработчиков с невероятной скоростью. Но что стоит за удобством? Ускорение или поверхностное мышление?

Разбираем, как меняется стиль программирования, поведение и архитектура кода, когда часть решений принимает нейросеть. Много примеров, кода, субъективных наблюдений и немного философии.

ИИ — это не просто автодополнение

В 2021 году, когда Copilot только начинал свое шествие, многие относились к нему как к новому автокомплиту. Но за прошедшее время всё стало сложнее: модели начали понимать контекст, “предсказывать” намерения, писать тесты, генерировать SQL-запросы, даже советовать архитектурные решения. И с этим начали происходить странные вещи.

Простой пример: типичный разработчик на Python.

# Python
def get_top_customers_by_revenue(customers: list[dict], top_n: int = 5) -> list[str]:
    return sorted(
        [c for c in customers if c.get("revenue")],
        key=lambda x: x["revenue"],
        reverse=True
    )[:top_n]

Copilot предлагает этот сниппет почти целиком после ввода def get_top_customers. Но знаешь ли ты, почему он предлагает key=lambda x: x["revenue"] вместо itemgetter? Это удобство или увод от знаний?

Когнитивные искажения: ты думаешь, что это ты думаешь

ИИ меняет поведение. Мы меньше держим контекст в голове, чаще соглашаемся с “разумной” подсказкой, даже если она неверна. Это явление в психологии называется “авторитетная автоматизация” — когда система с высоким доверием подавляет критическое мышление.

Когда Copilot предлагает решение, а ты жмёшь Tab — ты соглашаешься. Но на автомате. А если бы писал сам, может, подумал бы иначе.

Скорость ≠ качество

Есть класс задач, в которых скорость реально выигрывает: CRUD, логика форм, интеграции. Но ИИ-буст здесь работает как на стероидах: ты пишешь то же самое, но быстрее. Это прекрасно… до момента, пока не нужен нестандартный подход.

Сравним:

// Go
// ИИ предлагает такой код для фильтрации
func FilterAdults(users []User) []User {
    var result []User
    for _, user := range users {
        if user.Age >= 18 {
            result = append(result, user)
        }
    }
    return result
}

Почему мы вообще используем ИИ при программировании?

Всё просто: это удобно. Запускаешь редактор, подключаешь Copilot или Codeium, начинаешь печатать, и на экране появляется кусок кода, который... часто просто идеально вписывается в твои намерения. Это магия. Особенно когда ты пишешь:

// JavaScript
function groupBy(array, key) {
  return array.reduce((result, item) => {
    const groupKey = item[key];
    if (!result[groupKey]) {
      result[groupKey] = [];
    }
    result[groupKey].push(item);
    return result;
  }, {});
}

ИИ предлагает эту функцию почти сразу после ввода function groupBy. Это удобно, быстро и эффективно. Но когда каждый второй разработчик использует похожие сниппеты, возникает вопрос — где стиль? где изобретательность?

Проблема усреднённого стиля

Нейросети, обученные на массовом коде, не умеют думать. Они предсказывают. Это означает: они предлагают не лучшее решение, а наиболее вероятное. Часто — самое банальное.

Вот пример на Rust:

// Rust
fn fibonacci(n: u32) -> u32 {
    if n <= 1 {
        return n;
    }
    fibonacci(n - 1) + fibonacci(n - 2)
}

Это красиво? Да. Эффективно? Нет. Даже нейросети это понимают, иногда предлагая мемоизацию, но только если ты явно дашь понять, что тебе нужна оптимизация.

use std::collections::HashMap;

fn fibonacci(n: u32, memo: &mut HashMap<u32, u32>) -> u32 {
    if let Some(&val) = memo.get(&n) {
        return val;
    }
    let result = if n <= 1 {
        n
    } else {
        fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    };
    memo.insert(n, result);
    result
}

fn main() {
    let mut memo = HashMap::new();
    println!("{}", fibonacci(30, &mut memo));
}

ИИ не предлагает этот код сразу. Почему? Потому что он реже встречается. А значит, он не усреднённый. Он требует понимания, а не только синтаксиса.

Как ИИ влияет на архитектурные решения

Здесь начинается самое интересное. Когда программист использует ИИ-помощника, часто закладывается паттерн мышления: «быстрее собрать — быстрее выкатить». В краткосрочной перспективе это работает. Но в архитектуре выигрывает тот, кто думает на 3-4 хода вперёд.

Пример: генерация слоёв API

ИИ может сгенерировать:

# Python (FastAPI)
from fastapi import FastAPI, HTTPException

app = FastAPI()

@app.get("/users/{user_id}")
def get_user(user_id: int):
    # заглушка
    return {"user_id": user_id, "name": "John Doe"}

Но если ты проектируешь API на несколько лет — тебе нужны схемы, валидация, документация, декомпозиция. Что делает осознанный разработчик?

# Python (FastAPI с Pydantic)
from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
from typing import List

app = FastAPI()

class User(BaseModel):
    id: int
    name: str
    email: str

users_db = [
    User(id=1, name="Alice", email="alice@example.com"),
    User(id=2, name="Bob", email="bob@example.com")
]

@app.get("/users", response_model=List[User])
def list_users():
    return users_db

@app.get("/users/{user_id}", response_model=User)
def get_user(user_id: int):
    for user in users_db:
        if user.id == user_id:
            return user
    raise HTTPException(status_code=404, detail="User not found")

ИИ может это сгенерировать, но только если ты уже был на полпути. А это уже не помощь — это повторение. Не обучение, а догонялки.

Как меняется стиль программирования

Некоторые наблюдения, которые можно назвать "микро-рефакторингами мышления":

• Императивность возвращается. Даже в языках с выразительной функциональностью, ИИ предлагает базовый, иногда даже архаичный стиль.

• Поверхностные паттерны. Модели копируют популярное, не лучшее.

• Зарастание boilerplate-ом. Часто ИИ создает ненужную обвязку, особенно в тестах.

Парадокс: лучшее для джуниоров — ловушка для мидлов

Для начинающих ИИ — почти палочка-выручалочка. Он обучает паттернам, синтаксису, показывает, как можно. Но если ты уже middle+, возникает лень думать, лень читать доки. А там — новинки языка, интересные кейсы, нюансы, которые модель просто не знает.

А можно ли “переучить” мозг?

Один из способов — сознательное сопротивление: выключать подсказки, когда пишешь ключевую логику. Или использовать их как “ассистента”, не автора. Как в парном программировании: “ты мне идею — я тебе реализацию”.

Заключение: костыль или джетпак?

ИИ — это костыль, если ты опираешься на него в каждом шаге. Но это джетпак, если ты знаешь, куда лететь. Как и всё в жизни, польза зависит от осознанности. Главное — не отдать мозг на аутсорс.