How we express
what is inside the change,
what is outside,
and what must remain untouched

_{—Part of CSS Primer for the AI Era — CSS Communication Toolkit}

AI does not know where a change begins or ends.
It does not know what is in scope,
what is out of scope,
or what is dangerous to modify.

So, the third communication skill is simple:

We define 'the edges' of the change
before AI begins the work.

Boundaries are how we keep the system stable
while still moving forward.

When we say:

“Fix the spacing”

“Improve the layout”

“Make this responsive”

AI must decide:

• how far the change extends
• which selectors are included
• which components are related
• which patterns should be unified
• whether the HTML should change
• whether the layout should be refactored
• Without boundaries, AI assumes freedom.

A simple truth:

AI expands the change
unless we shrink the space
it can move in.

This is why boundaries are not optional —
they are the architecture of safe collaboration.

Every change has three edges:

1. The target
   What the change applies to.
2. The context
   What shapes the change but must not be altered.
3. The exclusions
   What must remain untouched.

We should name all three.

This gives AI a map of the work.

We point directly to the part of the system
that is allowed to change.

Examples:

“This selector is the target.”

“We are modifying only this component.”

“This block is the scope of the change.”

“Only this spacing rule is in play.”

“Only this media query is relevant.”

We make the target unmistakable.

A simple principle:

A clear target
limits what AI
is allowed to change..

'Context' is what shapes the behavior
but it must remain stable.

So, we say something like:

“This parent container is context 
— do not modify it.”

“These siblings are context 
— they must remain unchanged.”

“This grid defines the structure 
— keep it intact.”

“This variable set is context 
— do not rename or reorganize it.”

“This HTML is context 
— do not alter the markup.”

Context is the environment.
We show it so AI understands the constraints,
but we protect it
so AI does not rewrite the system.

Exclusions are the boundaries that keep the work safe.

To exclude something, we say:

“Do not modify other selectors.”

“Do not introduce new classes.”

“Do not reorganize the layout.”

“Do not refactor the component.”

“Do not change unrelated spacing rules.”

“Do not alter behavior on small screens.”

A simple truth:

Exclusions are how we
prevent accidental redesign.

They are the guardrails that keep the work
aligned with the moment.

A complete boundary statement looks like this:

“We are adjusting only this spacing rule.
The parent container and siblings are context — 
do not modify them.
Do not introduce new classes 
or change unrelated spacing.”

Or:

“We want this element centered.
The HTML structure is context — keep it unchanged.
Do not reorganize the layout 
or refactor the component.”

Or:

“We want this section quieter.
The color scale is context — use existing variables.
Do not add new colors or modify the palette.”

This is how we define the edges of the work.

We should name boundaries when we notice that:

• AI stops scanning the entire file
• AI stops trying to unify patterns
• AI stops refactoring unrelated parts
• AI stops rewriting the system
• AI focuses on the target
• AI respects the context
• AI avoids the exclusions

A quiet reminder:

Boundaries are not restrictions.
They are clarity.
They tell AI where the work lives.

Naming the boundaries of a change
is not a defensive move,
but an architectural one.

When we define:

• the target
• the context
• the exclusions

we create a safe, stable space
for AI to work inside.

A simple closing thought:

Boundaries keep the change small.
Small changes keep the system stable.
Stability keeps the collaboration possible.

• Suggested Next Reading: How to Describe Layout Intentions Clearly

_{Tony de Araujo —New York | Lisbon}

• Top↑
• Back to Topic ↔
• Home←