DRYにしすぎるとコードは干からびる
前置き
手前味噌ながら、弊社は高い開発生産性を評価され、Findy Team+ Award 2024, 2025 を2年連続で受賞した。華やかな受賞理由の裏側には様々な要因があるが、その中でも技術的な側面としてひっそりと、開発者が直接触れる作業領域に対して強く作用させていた力学のひとつが、本記事にて紹介する DRY との向き合い方(境界設計) である。
「最短距離」で走るつもりが、最速で消耗戦へ
早期のプロダクト開発では「まずはスピードを最優先」という判断がしばしば下される。だが、短期効率だけを信じて場当たり的な共通化、とりわけ誤った DRY を積み重ねると、ほんの1ヶ月後には、その短期効率こそが最大の足かせになって返ってくる。
初速を上げたつもりが、気づけば境界が溶けたコードベースのメンテに追われ、「本当にやりたい開発」に時間を使えなくなっていく。開発効率は時間とともに自然減衰するものだが、誤った共通化はその減衰曲線を自ら急角度に傾ける。
「アーリーだから多少雑でもいい」。
これは、最も危険な自己暗示の一つである。
最短距離で走るつもりが、気づけば最速で消耗戦へ。そんな入り口になりかねない。ゆえに、短期の小手先より、境界の明確さとルールだけは最初から守っておく。その投資対効果は、想像以上に高い。
この早期の過剰な共通化(境界の消失)に対する課題感は、決して弊社だけのものではない。実際、Google 社も2024年に Don't DRY your code prematurely と題した記事を公開し、話題を呼んだ。
また、先日開催された アーキテクチャカンファレンス 2025 においても、多くの登壇者が変更容易性(Modifiability)こそが持続可能な開発の最重要資産であると語り、AI時代だからこそ Adaptable AI(AIの変化に適応し続ける設計)が必要であるという議論が白熱していた。
AIはあくまで増幅器であり、人間が目的や境界を正しく定義しなければ、生産性は上がらない
会場で共有されたこの問題意識は、まさに本記事のテーマと直結している。
本記事の狙い: 未来の変更要求に対する「防御力」
DRY(Don't Repeat Yourself)が排除しようとする「重複」は、捉え方次第でいくらでも拡張できてしまう概念である。似た手順、似た入力、似たコード構造、あるいは似た雰囲気までもが「同じ知識」として見なされ、共通化の対象とされがちだ。
しかし、その自由度の高さこそが事故の温床となる。
本記事が問うのは、DRY を守るべきか否かという二元論ではない。「知識の境界線をどこに引けば、将来の変更要求に対して破綻しにくいか」という実務的な生存戦略である。特に、ある抽象化が適切であったかどうかは、設計時点では証明できず、未来の変更要求が来た瞬間に初めて 「耐えられたか、壊れたか」 という形で事後的に裁定されるという冷徹な前提に立つ。
抽象が正しいのではない。抽象を壊さずに現実が進むなら、それは「たまたま」正しかっただけである。
DRY と OAOO: 似て非なるもの
議論の解像度を上げるため、混同されがちな二つの原則を明確に区別する。
-
OAOO (Once and Only Once)
主にコード(実装)の重複を対象とする。同じロジックやデータ操作の記述をプログラム中で二回以上繰り返さないことを目指す、記述レベルの原則である。 -
DRY (Don't Repeat Yourself)
主に知識(ドメイン知識・ビジネスルール)の重複を対象とする。システム内における「ある特定の知識」の表現を一箇所に定めることを目指す、意味レベルの原則である。
重要なのは、DRY は単なるコピペ排除ではないという点である。
コードの見た目が酷似していても、背負っている文脈(変更理由)が異なるならば、それは「偶発的な重複」に過ぎず、無理に一つにまとめるべきではない。逆に、コードが多少異なっていても、同一のビジネスルールを分散して記述しているなら、それは DRY 違反となり得る。
知識は伸縮し、境界は溶ける
DRY における「知識」という言葉はあまりに便利である。便利すぎて、我々は無意識のうちに「似た手順」や「似た入力」までも「同じ知識」と呼んでしまう。
ここに罠がある。世界の複雑さを、我々の都合の良い綺麗な抽象に押し込めようとする行為は、一時的な快感をもたらす。理屈は整う。しかし、現実は整ってはくれない。
結果として何が起きるか。
例外的な仕様は「フラグ」になり、入力の差分は「オプショナル引数」になり、複雑な運用ルールは関数の内部分岐という「暗黙知」に吸収される。抽象化という名の元にコードは延命されるが、その代償としてドメインの境界は死ぬ。
多くの場合、この破綻は設計時点では不可視である。抽象化の良し悪しは、美しいクラス図が描けるかではなく、 変更要求が来たときに「既存のコードを汚さずに拡張できるか」 によってのみ決定される。
Claude Code などの AI ツール活用を前提とする LLM 時代では、このプロセスは爆発的に加速する。曖昧な境界の上では、もっともらしい破壊もまた、高速に量産されてしまう。
どこで DRY が誤用されるのか
DRY の誤用が最も顕著に現れるのは、粒度の大きい一連の手続き(ワークフロー)に対して、「だいたい同じ処理だから」という理由だけで共通化を強行し、その背景にある文脈の違いを無視してしまう場面である。
異なるユースケースを、見た目の類似性だけで一つにまとめる行為は、知識の一意化(Single Source of Truth)ではない。単なる ユースケースの乱暴な結合(Lumping) である。
その帰結として、以下のような症状がコードベースを蝕む。
- 想定外のパフォーマンス劣化(N+1問題の誘発など)
- 単一責任原則(SRP)の崩壊
- 境界が曖昧で、触るのが怖いビジネスロジック
以下では、具体的なコード例を通じて、健全なコードがどのようにして「地獄」へと変貌していくのかを段階的に追う。
具体例: ユーザ作成が「それっぽい共通化」で壊れていく
題材として「ユーザ作成」を取り上げる。一見単純なこの処理も、実際のプロダクト開発では以下のような要件の乖離(コンテキストの差分)が生じる。
-
通常登録:
name/age/emailが必須。登録後にウェルカムメールを送信する。 - 部署セットアップ経由: ユーザは作るが、メールは送らない(業務フロー上の都合)。
-
仮登録:
emailだけで作成可能。ただし一定期間で失効(TTL)する制約がある。 - 一括作成: パフォーマンスが重要。Validation は一括実行し、エラーもまとめて返したい。
ここから先の悲劇は、すべて 「これらの差分を一つの共通関数に吸い込もうとする」 ことから始まる。
前提: 外部I/O(グローバル前提)
説明を簡略化するため、リポジトリやメーラーはグローバルに存在する前提とし、例外処理やトランザクション制御も一部省略する。
from dataclasses import dataclass
from datetime import datetime, timedelta
# 外部I/O(実務ではDI推奨だが、説明のためグローバル変数とする)
user_repository = ...
user_query = ...
mailer = ...
audit = ...
@dataclass(frozen=True)
class UserRecord:
identifier: int
name: str
age: int
email: str
is_reserved: bool
reserved_until: datetime | None
Step 1: 素朴な手続き(この時点では健全)
初期段階。通常のユーザ作成ユースケースのみが存在する。
入力を検証し、保存し、副作用(メール送信・ログ)を実行する。手順がフラットに記述されており、どこがルールでどこが副作用かが明白である。
@dataclass(frozen=True)
class CreateUserInput:
name: str
age: int
email: str
def usecase_create_user(dto: CreateUserInput) -> None:
# --- バリデーション(不変条件のチェック) ---
if dto.age < 5:
raise ValueError("too young")
if len(dto.name) > 20:
raise ValueError("too long name")
if user_query.exists_email(dto.email):
raise ValueError("email already exists")
# --- 永続化 ---
user_id = user_repository.new_id()
user_repository.save(UserRecord(
identifier=user_id,
name=dto.name,
age=dto.age,
email=dto.email,
is_reserved=False,
reserved_until=None,
))
# --- 副作用 ---
mailer.send_welcome(dto.email)
audit.record("user.created", {"user_id": user_id, "flow": "regular"})
Step 2: 似た手順が増える(まだまとめなくてよい)
「部署セットアップ」の一環としてユーザを作成する要件が追加される。
作るモノは同じだが、「メールを送らない」 という文脈の差分がある。
ここで見えるコードの重複は、まだ「手順の断片」に過ぎず、知識の重複とは限らない。この段階での早すぎる共通化は、将来の負債を作り込む第一歩である。
@dataclass(frozen=True)
class SetupDeptInput:
dept_name: str
user_name: str
user_age: int
user_email: str
def usecase_setup_department(dto: SetupDeptInput) -> None:
# (部署初期化ロジックは省略) ...
# --- ユーザ作成(似ているがメール送信がない) ---
if dto.user_age < 5:
raise ValueError("too young")
# ... (同様のチェック) ...
user_id = user_repository.new_id()
user_repository.save(UserRecord(
identifier=user_id,
name=dto.user_name,
age=dto.user_age,
email=dto.user_email,
is_reserved=False,
reserved_until=None,
))
# NOTE: mailer.send_welcome は呼ばない
audit.record("user.created", {"user_id": user_id, "flow": "setup_department"})
Step 3: 見た目の重複だけで共通化する(事故の準備完了)
「バリデーションと保存処理が重複している」という理由で、共通関数 service_add_user が作られる。短期的にはコード行数が減り、合理的に見える。
しかし、この構造変更により 「ユースケースごとの微細な差分を、すべて共通関数側で吸収しなければならない」 という力学が働き始める。
# 共通化されたサービス関数
def service_add_user(dto: AddUserInput) -> int:
# バリデーションと保存をまとめた
if dto.age < 5: raise ValueError("too young")
# ...
user_repository.save(...)
return user_id
Step 4: 副作用が混入し、フラグが生える
「メールを送る/送らない」の差分を吸収するため、共通関数にフラグが生える。
この時点で、この関数は「ユーザを作る」という純粋な責務を超え、「呼び出し元の都合」を管理し始めている。
@dataclass(frozen=True)
class AddUserInput:
name: str
age: int
email: str
send_welcome: bool = True # <--- 呼び出し元の「都合」が引数に混入
def service_add_user(dto: AddUserInput, *, flow: str) -> int:
# ... (保存処理) ...
# フラグによる制御分岐
if dto.send_welcome:
mailer.send_welcome(dto.email)
audit.record("user.created", {"user_id": user_id, "flow": flow})
return user_id
Step 5: 一括作成が来て、意味論と性能が崩れる
「一括作成」の要件が入る。ここでは以下の要求がある。
- I/O をまとめたい(Bulk Insert)
- バリデーションエラーは即時スローせず、集約して返したい
しかし、1件処理用の共通関数 service_add_user をループで呼ぶ実装にすると、N回の I/O が発生し、最初のエラーで処理が止まってしまう。
def usecase_construct_all(dto: ConstructAllInput) -> None:
for u in dto.users:
# パフォーマンス問題(N+1)とエラーハンドリングの硬直化
service_add_user(
AddUserInput(..., send_welcome=False),
flow="bulk",
)
ここで壊れているのはパフォーマンスだけではない。「一括処理」というユースケースが本来持つべき処理粒度や例外設計が、共通関数の都合によって歪められている。
Step 6: 仮登録が来て、型が意図を失う(最終形)
トドメとして「仮登録」が入る。「email だけで登録可能、ただし name は不要」という要件だ。
共通関数を維持しようとすると、必須であったはずの name や age を Optional にせざるを得ない。
@dataclass(frozen=True)
class AddUserInput:
name: str | None # <--- 本来必須のものが Optional に
age: int | None # <--- 本来必須のものが Optional に
email: str
send_welcome: bool = True
reserved_ttl_days: int | None = None
def service_add_user(dto: AddUserInput, *, flow: str) -> int:
# 引数の組み合わせで「何を作るか」を推論するロジックが発生
is_reserved = (dto.name is None) and (dto.age is None)
if not is_reserved:
if dto.age < 5: raise ValueError("too young")
# ...
# 条件分岐の嵐
reserved_until = None
if is_reserved:
days = dto.reserved_ttl_days if dto.reserved_ttl_days else 7
reserved_until = datetime.utcnow() + timedelta(days=days)
# ... (保存処理) ...
この段階で、AddUserInput の型定義を見ても、何が必須で何が任意なのか、どの値がセットされていれば正解なのかが全く読み取れなくなる。
振る舞いは引数の複雑な組み合わせに依存し、仕様は関数の内部実装(if文の塊)に隠蔽された。知識は一意化されたのではなく、ドロドロに溶けたのである。
設計し直し: DRY を不変条件に限定し、手順と副作用を戻す
問題の本質は、共通化の対象を「不変のビジネスルール」ではなく、「一連の手順や都合」にまで広げてしまったことにある。
解決策はシンプルである。
- 守るべきルール(不変条件)を型(ドメインオブジェクト)に閉じ込める。
- ユースケースごとの手順(メール送信、I/O戦略など)は、呼び出し元に返す。
User を「不変条件の唯一の表現」とする
User クラスにファクトリメソッドを用意し、生成パターンごとの整合性をここで担保する。
これにより、型レベルで「正しく作られた User オブジェクト」の存在が保証される。
class DomainError(ValueError):
pass
@dataclass(frozen=True)
class User:
identifier: int
name: str
age: int
email: str
reserved_until: datetime | None
@property
def is_reserved(self) -> bool:
return self.reserved_until is not None
# ドメインルール(バリデーション)の集約
@staticmethod
def validate_regular_spec(name: str, age: int) -> None:
if age < 5:
raise DomainError("too young")
if len(name) > 20:
raise DomainError("too long name")
# ファクトリ:通常ユーザの生成ルール
@classmethod
def create_regular(cls, *, identifier: int, name: str, age: int, email: str) -> "User":
cls.validate_regular_spec(name, age) # ルール適用
return cls(identifier=identifier, name=name, age=age, email=email, reserved_until=None)
# ファクトリ:仮登録ユーザの生成ルール
@classmethod
def create_reserved(cls, *, identifier: int, email: str, ttl_days: int = 7) -> "User":
if ttl_days <= 0:
raise DomainError("ttl must be positive")
return cls(
identifier=identifier,
name="", age=0, email=email, # 仮登録固有の初期値
reserved_until=datetime.utcnow() + timedelta(days=ttl_days),
)
# DTO変換などの責務
def to_record(user: User) -> UserRecord:
return UserRecord(
identifier=user.identifier,
name=user.name,
# ...
)
Usecase: 差分は差分として書く
ルールの検証は User クラスが担っているため、ユースケース側は「手順」の記述に専念できる。コードの見た目上の重複は増えるが、それぞれのユースケースは独立しており、変更に強い。
A. 通常登録: メール送信を含む
def usecase_create_user(dto: CreateUserInput) -> None:
# 1. 重複チェック(ドメインサービス等の責務)
if user_query.exists_email(dto.email):
raise ValueError("email already exists")
# 2. ドメインオブジェクト生成(ここでルールが守られる)
user_id = user_repository.new_id()
user = User.create_regular(identifier=user_id, name=dto.name, age=dto.age, email=dto.email)
# 3. 永続化と副作用(このユースケース固有の手順)
user_repository.save(to_record(user))
mailer.send_welcome(dto.email) # <--- 明示的に記述
audit.record("user.created", {"user_id": user_id, "flow": "regular"})
B. 部署セットアップ経由: メールを送らない
共通関数にフラグを渡すのではなく、単に「メール送信の行を書かない」だけで済む。単純明快である。
def usecase_setup_department(dto: SetupDeptInput) -> None:
# ...
user = User.create_regular(
identifier=user_id,
name=dto.user_name,
age=dto.user_age,
email=dto.user_email,
)
user_repository.save(to_record(user))
# メール送信処理は記述しない
audit.record("user.created", {"user_id": user_id, "flow": "setup_department"})
C. 一括作成: I/O とエラー粒度を最適化
一括作成では「全件バリデーションしてから、まとめて保存」という固有のアルゴリズムを記述できる。共通関数に縛られないため、パフォーマンス最適化も容易である。
def usecase_construct_all(dto: ConstructAllInput) -> None:
errors: list[BulkError] = []
valid_users: list[User] = []
# 1) まとめて検査(エラー集約)
# User.validate_regular_spec を再利用することで知識の重複は防げている
for i, u in enumerate(dto.users):
try:
User.validate_regular_spec(u.name, u.age)
# ...
except Exception as e:
errors.append(BulkError(index=i, reason=str(e)))
if errors:
raise ValueError({"bulk_errors": errors})
# 2) I/O をまとめる(Bulk Insert)
# ユースケース層でコントロールできるため、N+1を回避可能
ids = user_repository.new_ids(len(dto.users))
records = []
for i, u in enumerate(dto.users):
user = User.create_regular(identifier=ids[i], ...)
records.append(to_record(user))
user_repository.bulk_save(records) # <--- 最適化されたI/O
このように、「ビジネスルール(User)」を共有し、「手順(Usecase)」を分離することで、変更容易性とパフォーマンスの両立が可能となる。
抽象化を導入してよいかを判断するチェックリスト
最後に、実務で「これ共通化したほうがよくない?」という誘惑に駆られた際に確認すべきチェックリストを提示する。
-
その共通化は「知識」を一意にするか?
単にコードの行数が似ているだけではないか? ドメインルールや整合性チェックを一箇所に集約しているならGOだが、手順の並びが似ているだけならSTOPしたほうがいい。 -
その関数の責務はユースケースに引きずられていないか?
「通常登録」と「仮登録」のように、ビジネス上の意味が異なるものを同じ関数で処理しようとしていないか?flowやmodeといった引数が必要になった時点で、それは危険信号である。 -
データの整合性を守る「構造体」として切り出せるか?
共通処理がデータの正しさを保証するものであるなら、手続き(関数)の一部として埋め込むのではなく、ルールを持ったクラスや構造体として独立させるべきである。 -
共通化によってパフォーマンス制約を固定化していないか?
1件処理の共通化が、将来のバルク処理の最適化(Bulk Insert等)を阻害しないか? -
変更頻度が高い部分を無理に一箇所に寄せていないか?
仕様が変わりやすいユースケース単位の手順(UI都合や通知ロジックなど)は、当面は重複を許容して個別に書く方が、結果的にメンテナンスコストが下がることが多い。
まとめ
DRY は「同じコードを 1 箇所にまとめる」ための原則ではなく、同じ知識・ビジネスルールを多重化しないための指針である。したがって、本来は別々に進化すべきユースケースを、見た目の類似だけでひとつの関数に押し込めてしまうと、
- パフォーマンス最適化の余地が消える
- 関数の責務が肥大化する
- オプショナル引数や条件分岐が増え、API が不透明になる
といった問題に直結する。
共通化の対象にすべきなのは、整合性ルールを一意に担保するための純粋な構造体 であり、どの操作をどの順序で呼ぶか、どのユースケースからどう使うかといった手順(オーケストレーション) の記述は、当面は多少の重複を許容していく方が、結果的にコスパ良好となることが多い。
特に、未知の多い初期フェーズでは、恣意的にすぐリファクタリングに走るのではなく、まずユースケースごとの手順を素直に記述しながらフラットなコードベースを育てることに徹し、あとで俯瞰することで「初めて」得られる尤もらしい洞察 をもとに、
- 何が純粋かつ不変なルールなのか
- 何がユースケース依存で変わりやすいのか
といった変更頻度の差異を見極めてから、ボトムアップ的に共通化を進めていく戦略を取ると、結果的に設計の健全性と開発効率の両方を最大化しやすくなると言える。
抽象が正しいのではない。抽象を壊さずに現実が進むなら、たまたま正しかっただけである。ゆえに、抽象を先に固定するのではなく、境界を保ったまま観測し、耐えたものだけを後から抽象として認定していく姿勢が重要である。
Appendix: AI-assisted な開発においては、型安全な境界設計はより重要となる
※本節で述べる内容は、特定の学術論文に直接依拠するものではなく、Copilot をはじめとする LLM ベースの開発支援ツールを実務で利用するなかで広く共有されつつある観測と経験則に基づくものである。
近年の AI-assisted な開発環境では、コード生成・補完・変換が従来より圧倒的に高速化し、「とりあえず動くコードを書く」こと自体のコストはほぼゼロに近づきつつある。しかしその一方で、抽象境界が曖昧なコードベースは、AI による支援との相性が著しく悪い という特性も認知されつつある。この解釈は、特に型安全性と契約駆動を重視する弊社においても概ね一致するものだった。
これは単に「AI に読みにくいコードはダメ」という話ではなく、もっと構造的・本質的な問題があることを意味する。以下では、この記事で扱ったような過剰な共通化が、AI 前提のソフトウェア開発においてどのように作用するかについて考察する。
AI のコード生成は型と境界を手がかりとして推論する
大規模言語モデルは、関数やメソッドの引数の型、データ構造の形状、インターフェースの粒度、責務の境界、例外条件や検証ロジック、関連するユースケースのパターンといった情報を手がかりに、コードの意味を推論している。
ゆえに、オプショナルだらけの入力データ定義、ユースケースを無理やりまとめた巨大な関数、前提が暗黙化した共通化は、AI が段階的に推論するための手掛かりを失わせる。その結果、誤った前提でコードが生成され、リファクタリング提案の品質が落ち、新機能追加時に一貫性のないパッチが提示されることが増える。
これは LLM の性能の問題というよりも、設計の品質が AI の推論可能性に直結していることを示している。
AI は明確なルールを理解しやすい
User クラスのように、ルールとデータをひとまとまりの構造体として閉じ込めた設計は、AI と相性がよい。通常登録と仮登録の生成経路が明示され、コンストラクタがどの状態を許容しどれを許容しないかが構造として表現されていると、AI は新しいユースケースでどの生成メソッドを使うべきか、バリデーションをどこに書くべきか、保存前にどんな状態遷移が必要かといった推論を正確に行いやすい。
逆に、オプショナル引数の組み合わせ次第で挙動が変わり、暗黙のデフォルトが多数あり、モードフラグで複数ユースケースを兼ねる関数は、解釈不能な塊になりやすい。結果として生成物が破綻しやすくなる。
AI-assisted なリファクタリングは型の境界単位で作用する
AI はリファクタリングや構造変換が得意である一方、その作用単位は型、メソッド定義、レイヤー境界、依存の方向性といった境界に強く依存する。境界が明瞭であるほど精度は上がるが、曖昧だと別ユースケースを統合した方がよいという誤提案や、逆に不変条件をユースケースごとに分離した方がよいという誤提案が生じやすい。バリデーションの場所やデフォルト値の推論を誤ることもある。
設計の曖昧さは、そのまま AI が壊すリスクになる。
境界が明確だと AI との協調作業が加速する
構造体が明確なルールを持ち、ユースケースが分離され、入力データ定義がユースケース粒度ごとに分かれ、共通化が最小限に収まっているコードベースでは、AI は既存構造に沿った拡張提案を行いやすい。新ユースケースの自動生成、I/O 最適化の提案、シリアライザや API スキーマの自動派生、変更影響範囲の推論などの精度が上がる。
抽象化のミスや境界の曖昧さは、人間の可読性を損なうだけでなく、AI にとっての推論可能性を奪うため、開発速度そのものに影響を与える。
最後に: AI時代の速さとは、コードを書く速度ではなく、変わり続ける力である
ソースコードを書くコストは劇的に下がった。事業を構成する要素のうち「ソフトウェアがカバーする領域」は日々拡大を続け、求められる要件の水準が高度になっていく一方、その開発サイクルも爆発的に加速し、機能リリースのスピード競争は激化の一途をたどっている。
この「加速」には罠がある。 AI を使えば、構造の崩れたコードも、誤った共通化も、これまでとは比較にならない速度で量産できてしまう。それは言わば、技術的負債をマッハで積み上げられる時代の到来とも言える。
そんな、事業環境がめまぐるしく変化する現在において、真に競争力を持つのは「最初にコードを書き殴ったチーム」ではない。市場のフィードバックを受け、仕様変更に耐え、システムを破壊することなく安全に進化させ続けられる(Modifiability を持つ)チームである。
今回紹介した「ルールを守る構造体」や「責務の分離」といった設計は、ドメイン駆動設計(DDD) における 戦術的設計 の一部ではあるが、これらは決して高尚な理論のためにあるのではない。これらは、AI による爆発的なコード増殖のなかで、「変更容易性」という最大の資産を死守するための、極めて実利的な防衛手段である。
ビジネスのコアをコードに反映させ、変更に強い構造を作る「戦略」を持つこと。これこそが、AI という強力な増幅器を積んだ我々が、壁に激突せずにトップスピードで走り続けるための唯一の条件なのかもしれない、と思う今日この頃。
Discussion
コピペ操作をすると、つい「 あれ、これ共通化出来るんじゃね?」と欲求が生まれてウズウズするので、そんな時はこの記事を思い出して一息つくようにします。