Writings

Your Terminal as Co-Developer

20 Jul 2026

Your Terminal as Co-Developer

Cover

The way we write code has shifted. Again.


A year ago, AI meant autocomplete. You typed, it suggested the next line.


That was useful. But it was still you doing most of the work. Today, something changed.

From assistant to agent

There's a difference between a tool that completes your sentences and one that understands your goal.
Agentic Coding is the second one.


You describe what you want to build. The agent reads your codebase, plans a series of actions, writes files, installs dependencies, runs commands, reads the error logs, and tries again.


You're not writing code anymore. You're directing.

The loop that changes everything

Here's how an agent works, under the hood:


Plan → Execute → Observe → Correct → Repeat


That loop is what makes it different from a simple chatbot.
The agent doesn't just answer. It acts. And if the result isn't right, it adjusts on its own.


It's the difference between asking someone "how do I fix this?" and handing the problem to someone who figures it out and comes back with a solution.

What this looks like in practice

I ran a live demo at a Galsen DEV meetup a few months ago.


Empty folder. A README describing a simple API. Nothing else.


One prompt to the agent:

"Read the README and build the project."


Two minutes later: the server was running, files created, dependencies installed and endpoints working.


Then I broke something on purpose. Changed a file and introduced an error.


The agent read the logs, understood what went wrong, and fixed it.

No hand-holding. No step-by-step instructions.

The tools making this possible

A few agents worth knowing:


OpenCode is open source, runs in the terminal, and works with Claude, GPT-4 and Gemini. Great entry point if you want to see how this works without a paid IDE.

bash
npm install -g opencode-ai
opencode

Claude Code is Anthropic's agent, also terminal-based. Particularly strong on large codebases and multi-file tasks.

bash
npm install -g @anthropic-ai/claude-code
claude

Cursor / Windsurf take an IDE-first approach, if you prefer a visual interface around the agent.


All of them share the same core idea: the AI doesn't wait for you. It moves.

What the agent does well

  • - scaffolding a project from scratch,
  • - refactoring across multiple files,
  • - writing tests,
  • - debugging known error patterns,
  • - reading and making sense of legacy code.

What it still gets wrong

  • - complex business logic that requires domain knowledge,
  • - architecture decisions that need context you haven't written down,
  • - long tasks where the context window runs out,
  • - looping on the same error without knowing when to stop.

This is where you come in.


The agent is fast and tireless. You provide direction, judgment, and taste.

Your role changed, not disappeared

Some people heard "the agent writes the code" and panicked.


That's the wrong read.


What actually shifted: the bottleneck moved.


Before, the bottleneck was writing code fast enough. Now, it's knowing what to build, how to structure it, and when to stop the agent from going sideways.


That's a higher-level skill. And it rewards developers who understand what they're building, not just how to type it.

A practical way to start

Pick a small project. Something you already know how to build.


Write a clear README: what the project does, what tech to use, what endpoints or features it needs.

bash
# Create your project folder
mkdir my-project && cd my-project
bash
# Add a README describing what you want to build
echo "# My Project" > README.md

Open OpenCode or Claude Code. Point it at the folder. Give it the README as context.

bash
# With OpenCode
opencode
bash
# With Claude Code
claude

Then give it a clear prompt:

Read the README and build the project.

Watch what it does. Don't just accept it blindly. Read the code. Ask it to explain. Push back when something feels off.


That's the loop you want to build with your agent.

The bigger picture

We're at the beginning of this.


The agents today are impressive. The ones in two years will be more capable, more reliable, and better at staying on track.


The developers who will thrive are those who learn to work with agents now, not those who wait until it's "stable."


Start now. Stay curious.


And if you want to explore this with a community, join us at Galsen DEV. We're figuring it out together.


This article is based on a talk I gave at Ndogou Coding 2026 in Thiès and a live demo session with the Galsen DEV community.


🎥 Watch the full recording on YouTube:

Agentic Coding #LiveKoor2026

📬 Subscribe.