Over the past few months, I've been working intensively with agentic tooling—primarily ChatGPT (including Codex) and GitHub Copilot. The impact has been substantial. Not incremental. Structural.

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.

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

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 agent 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 agent and myself resulted in solving problems that I likely would not have tackled—or completed—due to time constraints.

A New Development Loop

The workflow has evolved into something closer to this:

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

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

Practical Takeaways

1. Snapshot aggressively

When you reach a good state—commit it.

Agents 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
  • Agents → 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 an agent
  • Let work progress asynchronously

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

My 50cts

Agentic programming is not about replacing developers. It's about removing 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 you can translate intent into direction.