Hello Curious Coders,

AI has changed the way we write software, and it’s tempting to imagine these tools as magical co‑pilots capable of building entire systems for us. But in a reliability‑first ecosystem like Elixir, the real challenge isn’t teaching the AI to code — it’s teaching yourself how to collaborate with it responsibly.

This article — the first in our new Groxio series on AI‑augmented Elixir development — distills one of the foundational lessons I learned from studying with Bruce Tate. Together, we’ll explore five common ways developers interact with AI coding agents. Some of these modes are productive. Some are dangerous. And understanding the difference is key to keeping your systems clear, concurrent, and trustworthy.

The Issue Isn’t the AI — It’s the Process

One of the lines Bruce repeats often in class is:

“Quality code is just a series of good decisions made in a row.”

AI is incredibly fast, but it has no understanding of your architecture or design intent.

It doesn’t know:

• your invariants
• your constraints
• your domain
• the tradeoffs you’re balancing

When the model starts making decisions for you, the output might look impressive — but it’s often subtly wrong in ways that become expensive later.

To use AI effectively, you need the right structure.

This is the framework Bruce teaches, and the one I now apply daily.

The 5 Modes of AI‑Assisted Programming

These aren’t just techniques — they’re mindsets.
And each mindset produces a different kind of system.

1. Completion — The AI Follows Your Lead

This is the simplest, safest form of AI assistance: refined autocomplete.

You write something like:

def move_piece(board, piece) do

…and the model fills in the obvious details.

Completion works best when:

• your naming is clear
• your modules are structured
• your documentation points the model in the right direction

Completion doesn’t design anything for you — it simply accelerates what you already understand.

In Elixir, where small, composable functions shine, this is your everyday workhorse.

2. Mini Tasks — Give the AI Something Small and Checkable

“Mini tasks” are focused asks:

• “Refactor this function for clarity.”
• “Generate tests for this module.”
• “Write only the validation logic.”

You still own the architecture; the AI handles the grunt work.

This mode works beautifully with Elixir’s strengths:

• small functions
• clear data
• explicit transformations

Productive. Safe. Reliable.

3. Debugging — The AI’s Most Underrated Superpower

AI models are surprisingly good at spotting:

• off‑by‑one errors
• inconsistent logic
• broken invariants
• faulty assumptions

In the course, Bruce demos pipelines where the model helps experienced developers find mistakes and quality problems in codebases.

If you use AI for nothing else, use it for debugging.

4. Collaboration — The Gold Standard for Real Systems

This is where things get interesting.

In a collaborative workflow, you:

• give the agent context
• let it propose a change
• review every step
• maintain checkpoints
• guide the structure as the code evolves

It feels like pair programming with a very fast, occasionally confused junior developer.

You remain the architect.
The AI becomes a high‑throughput assistant.

This mode consistently produces maintainable, predictable, scalable Elixir systems.

5. Vibing — The Seductive Shortcut With a Heavy Price

“Vibing” means giving the model one broad prompt:

“Build the whole thing.”

And it will.

But it also:

• invents abstractions you didn’t approve
• introduces inconsistencies
• hides flaws behind layers of generated code
• creates complexity faster than you can understand it

The results look impressive, but they rarely hold up in real systems.

Bruce says it best:

“Vibing is fantastic for prototypes.
It’s poison for systems you plan to keep.”

Why This Matters More in Elixir

Elixir’s strengths — immutability, fault tolerance, explicit processes — don’t automatically appear in AI‑generated code.

In fact, the model often defaults to patterns that conflict with Elixir’s philosophy:

• imperative steps in a functional world
• concurrency that doesn’t match the BEAM
• errors hidden instead of surfaced
• arbitrary state leaking into places it shouldn’t be

Without human architectural guidance, AI drifts away from reliability.

That’s why collaboration — not automation — is the key.

A Simple Map for Using AI Tomorrow

Here’s the quick guide Bruce gives to his students:

Completion → speed
Mini Tasks → clarity
Debugging → correctness
Collaboration → real systems
Vibing → throwaway experiments only

This sequence will guide the rest of the series and help you use AI safely while keeping your systems aligned with Elixir’s principles.

Closing Thoughts — AI Should Accelerate Good Thinking, Not Replace It

AI can generate code at blinding speed.
But speed without direction just gets you lost faster.

Elixir asks us to value clarity, correctness, and thoughtful design.
Working with AI doesn’t change that — it amplifies it.

In the next article, we’ll look inside the “mind” of these models:
how they store information, why they forget things, and what those limitations mean for your day‑to‑day Elixir work.

See you in the next chapter. — Paulo Valim and Bruce Tate