Smaller Self Contained Units: Writing Code that AI Can Work With

As AI becomes more involved in software development, an important question appears. How should software be shaped so that AI tools can contribute meaningfully

Modern AI systems can assist with coding and refactoring, but they often struggle when a codebase is large and many parts depend on one another. Future models may read far more context at lower cost, yet even with those improvements there is practical value in shaping software as a collection of smaller self contained units.

Why Smaller Units Might Work Well for AI and Humans

AI tools tend to perform better when the area they work on is narrow and clearly defined. This usually means:

• one clear responsibility
• minimal unnecessary dependence on other parts
• predictable logic
• behaviour that can be tested or understood on its own

When these properties exist, intent becomes clearer, misunderstandings reduce, and the cost of using AI tools is lower. Larger structures often require more explanation, more context, and more caution.

This leads to a natural question.

What if our software was shaped as many smaller self functioning units, each understandable on its own, each communicating through simple and predictable boundaries

This approach benefits development even without AI involvement, and aligns well with how AI systems reason about behaviour.

The Shift Toward Components That Act Like Mini Systems

A small self contained unit is not just a reduced file. It is a piece of behaviour that can stand on its own without needing to understand the entire system.

Typically such a unit has:

• a focused purpose
• clear inputs and outputs
• very little shared or hidden state
• tests that express expected behaviour

This lowers the amount of information needed before making a change. It becomes easier to improve or replace individual parts without affecting unrelated areas. Even if future AI systems can scan huge repositories, software shaped in this way remains easier to maintain and evolve.

Patterns That Support Smaller Self Contained Units

Some well known patterns naturally encourage clear boundaries and focused behaviour. They are useful in environments where interaction, state, and visual changes happen often.

State Machines and Explicit Behaviour Models

By expressing behaviour through states and transitions, logic becomes visible and easy to understand. Each state forms a clear and predictable unit.

Plugin Style Feature Units

Features can be created as independent pieces that attach to the rest of the system through simple boundaries. This reduces unnecessary entanglement and keeps updates contained.

Pure Functional Programming Principles

Small pure functions free of side effects form dependable building blocks. They are easy to test and easy for AI tools to understand because their entire behaviour is contained within the function itself.

These approaches are not tied to any specific framework or paradigm. They simply support the idea of shaping software as smaller understandable parts.

Structures That Increase Complexity

Certain styles tend to require far more context before making any change. Examples include:

• deep inheritance structures
• classes with many responsibilities
• behaviour scattered across many files
• shared global state and heavy side effects

These patterns are not wrong, but they raise the cognitive load for both humans and AI systems.

Moving Toward Smaller Self Contained Units

This direction does not require a full rebuild. It can grow gradually.

1. Extract focused areas from large complex sections.
2. Introduce clear boundaries where communication happens.
3. Reduce unnecessary shared state.
4. Use tests to express the intended behaviour.
5. Improve structure continuously rather than all at once.

Smaller units produce smaller prompts for AI tools, reduce cost, and improve reliability. The same structure also benefits long term maintenance and human understanding.

Looking Ahead

As AI becomes a more active part of software creation, our architectural choices may shift toward structures that support clearer interaction between humans and AI systems. Smaller self contained units offer one promising direction. They reduce cognitive effort, strengthen boundaries, and make behaviour easier to understand.