What happens when you don’t just build agents—but use agents to build agents?

In my session “Agent Stories Part 1: Copilot Studio agent development with an agentic approach”, I walked through a very practical and hands-on example of how agent development itself is changing.

This wasn’t about theory.
It was about how real solutions are being built today—and how the development process itself is evolving.

From Traditional Development to Agentic Development

Traditionally, building solutions means:

  • Writing specifications
  • Implementing step by step
  • Testing and iterating

With agentic development, the model changes:

  • You define the intent and context
  • Agents execute large parts of the implementation
  • You shift from builder → to reviewer and orchestrator

The key shift:

Development becomes less about writing everything yourself—and more about guiding intelligent systems.

The Setup: Building in a Controlled Environment

The approach demonstrated started with a practical challenge:

Many tools (e.g., Claude Code, GitHub Copilot CLI) cannot be installed directly in corporate environments.

The solution:

  • Use an Azure-based development environment
  • Connect via tools like Visual Studio Code
  • Let agents operate inside a controlled sandbox

This enables:

  • Experimentation without risk
  • Flexibility in tooling
  • Separation from production environments

Real Development Flow: From Prompt to Working Solution

The most important insight from the session is how the development flow actually looks.

Instead of manual implementation:

  1. Define a clear prompt/specification
  2. Let an agent generate:
    • Agent configurations
    • Logic
    • Flows and integrations
  3. Review and refine the output

Even complex scenarios were built this way:

  • Multi-agent setups (parent + several child agents)
  • Data classification scenarios
  • Integration with Power Automate and apps

Multi-Agent Development… Built by Agents

One of the most interesting parts was the architecture built using this approach.

Example solution:

  • One main agent
  • Multiple child agents, each with a specific responsibility

In the demo:

  • Different agents evaluated data from multiple perspectives
  • Each returned its own result (e.g., classification outputs)
  • The main agent combined the results

This mirrors what we saw in architecture sessions:

Even development itself is moving toward structured multi-agent systems.

Speed: From Days to Hours

One of the biggest impacts is speed.

According to the session:

  • Tasks that would normally take days
  • Were reduced to hours of guided iteration

The difference comes from:

  • Automating repetitive work
  • Generating boilerplate logic
  • Reusing patterns instantly

However, the process is not “hands-off”.

The New Role: From Developer to Reviewer

A critical insight:

You cannot fully trust the output.

Even though agents:

  • Generate code
  • Create flows
  • Configure solutions

They still require:

  • Human validation
  • Testing
  • Understanding of the implementation

This creates a new role:

Less coding, more reviewing, validating, and guiding.

Quality: Better or Just Faster?

Speed is one thing—but does quality improve?

The session showed that:

  • With good specifications → quality improves significantly
  • With weak prompts → results degrade quickly

In practice:

  • A bad prompt produces low-quality output
  • A well-defined use case produces usable results very quickly

Which reinforces a key principle:

The quality of the outcome depends on the quality of the input.

Extending Beyond Agents: Full Solution Generation

The approach was not limited to Copilot Studio agents.

Agents were used to generate:

  • Power Automate flows
  • Model-driven apps
  • UI components and dashboards

In some cases:

  • Entire flows were created automatically
  • Patterns from existing implementations were reused
  • Even logging and error handling structures were replicated

This shows how far agentic development can go:

Beyond agents → into full solution development.

The Practical Reality: Still Not Fully Autonomous

Despite the impressive results, there are clear boundaries.

The process still requires:

  • Step-by-step validation
  • Iterative refinement
  • Controlled environments

In practice:

  • Not everything can be automated end-to-end
  • Some actions still require manual steps
  • Deployment and governance need oversight

Which means:

This is not “automation replacing development”—it’s accelerating it.

Key Lessons from the Session

A few very practical takeaways emerged:

  • Start with clear specifications, not vague prompts
  • Break solutions into smaller agent responsibilities
  • Let agents handle the repetitive work
  • Always review and validate outputs
  • Use controlled environments for experimentation

And perhaps the most important:

The value is not in replacing developers—it’s in amplifying them.

Final Thoughts

Agentic development is not a future concept—it is already happening.

And it changes the development mindset:

  • From building everything manually
  • To guiding systems that build for you

For experienced developers, this means:

  • Less time on boilerplate
  • More time on architecture and validation

For organizations, it means:

  • Faster delivery
  • Potentially higher quality
  • New ways of structuring development work

And for everyone involved:

The question is no longer “how do I build this?”
But “how do I guide an agent to build this correctly?”