Over the past few months, I've been deeply immersed in agentic programming — working with AI-assisted tooling: primarily ChatGPT (including Codex) and GitHub Copilot.

The impact has been substantial. Not incremental. Structural.

Agentic Programming: From Idea to Implementation at the Speed of Thought

Strictly speaking, not all of these tools are agentic. Copilot, for example, is reactive—it responds to what you type. But when combined with systems capable of multi-step reasoning, execution, and iteration, the overall workflow becomes agentic in nature.

And that is where the real shift happens.

I'm now able to build, refactor, and explore ideas that I previously wouldn't even start—simply because the time investment would not justify the outcome.

That constraint is gone.

From Friction to Flow

What stands out most is how natural the interaction has become. I no longer "prompt engineer" in the traditional sense. I describe intent—verbally, technically, and functionally—and the system interprets it correctly in most cases.

This changes the development model:

  • I explain architecture, not syntax
  • I describe behavior, not implementation details
  • I focus on direction, not mechanics

The result is that entire refactorings—such as migrating legacy codebases to vertical slice architecture with clean boundaries—can be executed in under 30 minutes.

That used to be a multi-day effort.

Exploration Is Now Cheap

The real shift is not just speed—it's optionality.

Exploration used to be expensive:

  • You had to commit time before knowing if something would work
  • Refactoring carried risk
  • Dead ends were costly

Now:

  • Try something → evaluate → discard or keep
  • Revert in seconds using Git
  • Iterate without hesitation

This effectively removes the psychological barrier to experimentation.

I routinely try approaches I would have previously dismissed. Not because they were bad ideas, but because they were too expensive to validate.

The Agent as a Technical Partner

One of the more surprising aspects is how deep the analysis can go when the system gets stuck.

In complex scenarios, I've seen it:

  • Inspect API surfaces across assemblies
  • Reason about abstractions and contracts
  • Drop down into IL when necessary to understand behavior

This is not superficial assistance. It's analytical collaboration.

In over 95% of cases, the combination of the system and myself resulted in solving problems that I likely would not have tackled—or completed—due to time constraints.

Agentic Programming: A New Development Loop

The workflow has evolved into something closer to this:

  1. Define intent (architecture, feature, or refactor)
  2. Let the system execute (partially or autonomously)
  3. Evaluate outcome
  4. Either:
    • Commit and continue
    • Or revert and try again

This loop is fast, low-risk, and highly productive.

It is not fully autonomous—but it is no longer purely manual. It sits in between: a human-in-the-loop, agent-like system.

Practical Takeaways

1. Snapshot aggressively

When you reach a good state—commit it.

These systems are powerful but not conservative. They can degrade a codebase just as quickly as they improve it. Without checkpoints, you risk losing valuable intermediate states.

2. Use Git as your safety net

Commit often. Revert without hesitation.

Git becomes more than version control—it becomes your experimentation boundary.

3. Optimize for experimentation

Do not overthink changes upfront.

Try → evaluate → adjust.

The cost of being wrong is now negligible.

4. Model selection matters

Different models have different strengths:

  • Lightweight models (e.g., GPT-5 mini) handle a surprising amount of work
  • Mid-tier models (e.g., GPT-5.4) provide strong consistency
  • High-end models (e.g., Claude Opus 4.6) excel in deep reasoning and complex refactoring

Choosing the right model for the task directly impacts output quality and cost.

5. Budget realistically

Usage scales with ambition.

1000–1500 RU/month (€30–€40) is a practical range for sustained, high-value usage. The ROI is not marginal—it replaces hours or days of engineering effort.

6. Use the right interface for the task

Each interface has a role:

  • Web / CLI → planning, ideation, decomposition
  • Editor (Copilot) → active implementation (reactive assistance)
  • Agent-like systems → executing refined stories or larger changes

This separation improves efficiency and reduces friction.

7. Work asynchronously—even on mobile

One unexpected benefit: location independence.

Even from a phone (e.g., during a train commute), you can:

  • Define tasks
  • Instruct a system
  • Let work progress asynchronously

You're no longer bound to a full development setup to move work forward.

My 50cts

This is not just “AI-assisted development.”

What’s emerging is an agentic development loop—a workflow where intent is translated into execution through systems that can reason, act, and iterate with you.

It does not replace developers.

It removes the constraints that prevented developers from exploring, iterating, and executing at scale.

The limiting factor is no longer time.

It's imagination—and how effectively agentic programming lets you translate intent into direction.