Igor Janković, Lead Software Engineer at Levi9, shares practical insights on automating development workflows through GitHub Copilot integration with MCP servers at our recent TuesdAI workshop.
We’re living through a fascinating yet challenging time in software development. AI is fundamentally reshaping not just how we work today, but how we’ll work in the near future. Client expectations are rising exponentially, and the pace at which we use development tools is about to change drastically.
“We’ll be working more with agents and less with manual coding,” explains Igor Janković, Lead Software Engineer at Levi9. “We’re transitioning from implementers to orchestrators – managing AI agents and validating their work rather than writing every line of code ourselves.”
AI Adoption: A Moving Target
When discussing AI adoption within organizations, it’s tempting to celebrate reaching 80% or 90% adoption rates. But that’s missing the point. AI adoption is a living metric that changes daily. New capabilities emerge constantly – some are fleeting trends, but many are here to stay and will fundamentally reshape our industry.
The goal isn’t just to have an AI license and write the occasional prompt. We’re already beyond that baseline. The real opportunity lies in utilizing these tools to their full potential, automating workflows, and staying in step with the rapid pace of innovation.
Automation in Action: End-to-End Workflow
The true power of MCP integration becomes clear when you see an entire development workflow automated through predefined prompts. Here’s what happens when you simply type implement ticket:
The Automated Journey
- Fetches the issue from Jira and analyzes requirements
- Posts a comment: “Started working on this ticket”
- Moves the ticket to “In Progress” status
- Creates a new branch from main (e.g., LM-120)
- Implements the functionality according to specifications
- Creates a Pull Request on GitHub
- Updates the Jira ticket with a link to the Pull Request
- Transitions the ticket to “Code Review” status
All of this happens autonomously, with optional approval gates for each action. Developers can choose to approve each step for transparency or allow the agent to execute read-only operations automatically.
Documentation: From Afterthought to Foundation
Documentation has traditionally been either non-existent or hastily written just to check a box. It quickly becomes outdated and loses value. In the AI era, this paradigm must shift dramatically.
“Documentation will become the foundation of everything,” Igor emphasizes. “The quality of our code and products will depend on it because documentation provides the context we give to LLMs.”
Automated Documentation Generation
With the same MCP integration, agents can:
- Analyze shell scripts or code components
- Create comprehensive Confluence pages automatically
- Link documentation directly to relevant tickets
- Keep information current without manual intervention
When new team members join a project, quality, up-to-date documentation means they can get context from the documentation rather than constantly interrupting colleagues for explanations. The same applies to AI agents – good documentation provides the context they need to perform effectively.
Visual Documentation: Automated Diagram Generation
One of the most impressive use cases is generating flow diagrams directly from code. With a simple generate diagram prompt, an agent can:
- Analyze AWS Step Functions defined in CDK
- Understand the workflow and dependencies
- Generate a complete Draw.io diagram with legend
A task that would typically require three hours of manual work – positioning elements, routing arrows, avoiding overlaps – is completed in minutes with a comprehensive visual representation of complex processes.
The Context Principle
As with all AI interactions, the quality of output directly correlates with the quality of input. The best approach includes:
- Provide examples – More valuable than verbal explanations
- Define expectations clearly and precisely
- Use concrete use cases rather than abstract requirements
“Many people give up on AI because they think it doesn’t work well,” Igor notes. “But we’re just giving it poor context. The amount of context we provide determines the result we get – no different than working with people.”
Cost Optimization: Strategic Model Usage
Effectively using AI tools requires a smart strategy to avoid exhausting premium tokens before month’s end:
- Powerful models (Claude Sonnet, Opus) – for planning and complex tasks
- Free/lightweight models – for implementation when steps are clearly defined
“Use the strong models to create the plan. Once you have all the steps defined, let the free models handle the implementation,” Igor suggests.
Multi-Session Workflows: Parallelizing Development
Recent updates to GitHub Copilot in VS Code have introduced multi-session capabilities that change how developers work:
Background and Cloud Execution
Instead of working on tickets sequentially, developers can:
- Launch multiple agents in parallel
- Each agent works in an isolated Git worktree
- No conflicts between different implementations
- Review all completed work when agents finish
When you initiate a task, you have two execution options beyond the standard mode:
- Cloud – Runs on GitHub’s cloud infrastructure with your codebase
- Background (CLI) – Runs locally through GitHub Copilot’s CLI interface in an isolated worktree
“You can launch multiple different tasks in parallel while you’re in meetings or leading your team,” Igor explains. “When everything’s done, you come back, see who finished what, review the work, and validate whether it’s correct. The Pull Request is already created through MCP – you just need to approve it.”
The Future: Pipeline Integration
While manually triggering agents through prompts is already powerful, the next evolution is integrating agents directly into CI/CD pipelines:
- Automatic documentation updates on every code change
- Automatic diagram regeneration when architecture changes
- Continuous validation and quality through AI-powered review
Consider the common scenario: requirements change six months after initial implementation. Development completes the changes, QA tests successfully, code goes to production – but everyone forgets to update the flow diagrams. With automated agents in the pipeline, this documentation debt disappears.
Developer Responsibility in the AI Era
Despite the power of automation, developer responsibility remains paramount. AI agents are tools that require human oversight.
“We’re still critically important and carry significant responsibility,” Igor stresses. “We can’t transfer responsibility to the agent. We’re responsible for the code AI generates because we’re the ones who approve or decline what we receive.”
There have been cases where developers rely too heavily on AI, letting it generate code or documentation without proper review, only to discover the AI hallucinated incorrect information. The agent does the work, but humans must validate the results.
Practical Recommendations
1. Define Custom Prompts
GitHub Copilot allows predefined prompts that specify:
- Which mode to use (Agent mode vs. Ask mode)
- Which tools the agent can access
- Which model to use
- What the expected outcome is
This eliminates the frustration of selecting the wrong model or tools mid-workflow.
2. Leverage Examples for Better Results
When generating diagrams, PDFs, or other complex outputs, think about multi-step approaches:
- For diagrams: Generate XML rather than images directly
- For PDFs: Generate HTML first, then save as PDF
- Provide example patterns for consistent styling
3. Stay Current with Trends
“AI adoption isn’t ‘I have a license and I type prompts,'” Igor emphasizes. “We’ve already moved beyond that baseline. We need to use all these tools, track what’s coming, and maximize their utility.”
The learning process is continuous. Separate signal from noise, identify what truly adds value, and adapt to a pace where mastering today’s approach isn’t enough – you need to stay aware of faster, better methods emerging constantly.
The Path Forward
The transformation from code writer to AI orchestrator represents a natural evolution in software development. Just as programming advanced from machine code to modern high-level languages, AI-powered development is the next step in that progression.
Organizations that embrace this shift – those that experiment with these tools, share knowledge across teams, and build expertise in AI orchestration – will have a significant competitive advantage. Those that treat AI adoption as a checkbox exercise will fall behind.
The future belongs to developers who can effectively manage multiple AI agents, validate their output critically, and continuously adapt to emerging capabilities. The question isn’t whether this transformation will happen, but how quickly your organization will embrace it.
***This article is part of the AI9 series, where we walk the talk on AI innovation.***
In this article:
Written by:
Igor Janković
Lead Software Engineer @ Levi9
