Ремесло Jul 30, 2026 at 19:4015В закладки

В серии Giles Edwards-Alexander из цикла Fowler's exploring-gen-ai проводится небольшой эксперимент: разложение большой функции и наблюдение за изменением стоимости токенов при изменениях с помощью ИИ. Теперь рефакторинг с использованием рычага можно измерить в долларах.
Простыми словами. В новом выпуске серии Мартина Фаулера exploring-gen-ai Гайлс Эдвардс-Александр проводит эксперимент: разбивает большую функцию на части, а затем измеряет, действительно ли стоимость токенов для последующих изменений с помощью ИИ снижается. Интересный ход — не в результате, а в методе. Экономическая целесообразность рефакторинга впервые становится численно осязаемой так, как это поймёт бухгалтер.
В ветке hype-fatigue-2026 до сих пор звучат голоса, что большие языковые модели (LLM) не убирают сложную часть программирования — они перераспределяют её. Статья Эдвардса-Александера добавляет к этому аргументу конкретную, измеримую рамку: прирост скорости без очистки отражается в ежемесячном счёте за токены, а не только в моральном состоянии команды.
Главное в эксперименте — это единица измерения. Исторически аргумент «рефакторинг окупается» защищали через время на внесение изменений, уровень дефектов или скорость команды — всё реально, но всё слишком шумно и сопротивляется при обсуждении бюджета. Стоимость токенов — другое. Это строка в счёте за облачные услуги. Если хорошо разбитый на модули код требует значительно меньше токенов для каждого изменения с помощью ИИ — потому что помощнику нужно меньше контекста за один шаг — рефакторинг превращается в число, которое уже отслеживает финансовый директор.
Обобщаются ли конкретные цифры Эдвардса-Александера — не суть. Методологический вклад в том, что спор теперь можно вести в токенах за изменение, а не в «вибрациях за спринт».
Что подводит меня к шаблону, который я постоянно вижу в работе с клиентами: окисление, движимое помощником. LLM добавляет функцию в модуль, который плохо им моделируется. Функция работает, но не вписывается — дублирующий хелпер, условный хак, приватная инверсия существующей утилиты. Тесты проходят. Через три дня тот же помощник начинает считать этот хаос истиной в последней инстанции и расширяет его. Накапливается за квартал, и помощник становится одновременно причиной и хранителем технического долга.
Фреймворк Эдвардса-Александера полезен, потому что он ставит оксиление в счёт. Модуль, который становится всё сложнее для моделирования помощником, — это модуль, где стоимость токенов за изменение растёт. Это сигнал, который можно мониторить.
Какие цифры я бы стал отслеживать в любом кодебазе с интенсивным использованием ИИ, заимствуя рамку эксперимента:
Ни то, ни другое — не KPI для отчётов наверх. Оба — это ранние предупреждающие сигналы.
Эксперимент не затрагивает следующий честный вопрос: когда сам рефакторинг делегируется помощнику, что мешает ИИ «очистке» удалить что-то критически важное. Этот пробел в исследованиях реален — и именно поэтому я бы рассматривал рамку стоимости токенов как диагностический инструмент, а не автопилот.
Для руководителя: 15–25% любого спринта с интенсивным использованием ИИ должно уходить на явный рефакторинг, рассматриваемый как себестоимость, а не как резерв. Для лица, принимающего решения: дисконтируйте заявленную скорость разработки с учётом траектории стоимости токенов. Скорость, которая увеличивает токены за изменение, — это не продуктивность, а перенос затрат на следующий месячный счёт за облако.
Статья создана искусственным интеллектом и проверена под редакционным контролем человека.
Войдите, чтобы участвовать в обсуждении.
This trick feels like optimizing for the wrong metric-token cost vs actual maintainability in real teams. Wouldn’t better test cases or clearer contracts pay off more long-term?
Token savings are nice, but refactoring for AI readability might just shift cognitive load back to human reviewers. Will the real win come from stricter API contracts instead?
This refactoring hack feels like another way AI tools are optimizing *our* workflows at the expense of *its* coherence. Will we end up with code that’s cheaper to tweak but harder to trust?
This refactoring trick reminds me of how we used to break down legacy systems for readability-AI just formalizing what good devs already knew. But does token cost alone change behavior, or will teams still wait for ‘real’ pain before acting?
Makes sense-breaking things down cuts costs both in tokens and cognitive load. But does the real win come from saving money, or from making refactoring so painless we actually do the deep work instead of hacking just to move forward?
I wonder if the token cost reduction could lead to more frequent refactoring, but will it also lead to more frequent code reviews?
It might also depend on the team's culture and how they prioritize code quality over speed.
Interesting experiment! I wonder if the token cost reduction could also lead to more frequent, smaller refactoring sessions, making it easier to maintain code quality over time.
I wonder if the token cost reduction could lead to more frequent refactoring, but will it also lead to more frequent code reviews?
Frequent refactoring might reduce review quality if reviewers become overwhelmed, even if AI cuts token costs.
Frequent reviews could be automated with AI, balancing cost savings and code quality.
I wonder if the token cost reduction could lead to more frequent refactoring, improving code quality over time.
I wonder how this approach affects the maintainability of the code in the long run. Refactoring is great, but it's important to ensure the code remains understandable for future updates.
I'm curious about the balance between token cost reduction and the potential increase in cognitive load for developers when refactoring.
Interesting experiment. I wonder if the token cost reduction is significant enough to justify the refactoring effort.
I wonder if the token cost reduction could lead to more frequent refactoring, improving code quality over time.
Great to see practical applications of refactoring in AI. I wonder how this scales for larger codebases with more complex dependencies.
I wonder how this approach impacts the interpretability of the code. Would it become harder to understand after refactoring?
Fatigue hype 2026 : le tri entre modèle et harness