The same data shape in several layers (DTO, model, entity)

Code that already exists: one of the ways AI coding agents bloat software, from lessloc's pattern catalog. What lessloc does: copy catches identical type bodies.

What makes the same data shape in several layers (DTO, model, entity) a bad practice?

The standard that calls it a bad practice: DRY.

What does lessloc do about the same data shape in several layers (DTO, model, entity)?

copy catches identical type bodies.

• copy (tier 1): A block of dupLines code lines that also exists elsewhere, or a function with the same body as another under other names.

Examples

Caught as copy:

from dataclasses import dataclass


@dataclass
class UserDTO:
    id: int
    name: str
    email: str
    active: bool
    plan: str
    seats: int
    created: str
    region: str


@dataclass
class UserRecord:
    id: int
    name: str
    email: str
    active: bool
    plan: str
    seats: int
    created: str
    region: str

Written well:

from dataclasses import dataclass


@dataclass
class Account:
    owner: str
    limit: int

Related patterns

The other patterns in Code that already exists:

• Reimplementing a helper the project already has: lessloc gives every session the rule: take what is already in the codebase before new code.
• Copying a rule another function owns: lessloc catches it as repeated-literal.
• Keeping old and new versions side by side: lessloc gives every session the rule: one implementation per rule.
• Rebuilding what the standard library or framework has: lessloc gives every session a rule against it and catches it as simpler and reinvented.
• Copy-pasted test cases instead of one parametrized test: lessloc catches it as copied-tests.
• A second library for a job an installed one already does: new-dependency names the library that is already installed.
• The same CSS declarations under another selector: lessloc catches it as style-copy.