Agentic Development Lifecycle (ADLC): agentic development with autonomous AI agents – a practical adoption plan
Updated 3 August 2026
A change with no precedent in the history of technology hit the software industry at the turn of 2025 and 2026. Within just a few weeks, OpenAI, Anthropic and other leading AI labs shipped a generation of agentic tools so capable that they rewrote the basic rules of how development teams operate. Data from the field: Uber reported that 84 % of its developers are active users of agentic tooling and that 65–72 % of all code is now generated by AI. Spotify went even further: their best engineers reportedly haven't touched code at all since December 2025 (allegedly).
At Ackee, we could have just watched and waited… Instead, we decided to build our own framework for introducing agentic development in a structured way — without chaos, without it being just a trendy buzzword, and so that we could post on LinkedIn about how we're not missing the train.
ℹ️ What is the Agentic Development Lifecycle (ADLC)
Agentic Development Lifecycle (ADLC) is a development cycle in which autonomous AI agents take over planning, implementation, testing and debugging. Unlike the classic SDLC, it does not assume that a human writes the code — the developer defines the requirements and the architecture, orchestrates the agents and validates the output.
That this is not just an internal topic for software houses is clear from the debate around the stalled digitalisation of the Czech building permit process. Asked why the originally planned government system will now never be built, one of the reasons given was how quickly the possibilities of software development have shifted:
„The current AI era makes it technically fairly easy to rebuild anything. With autonomous AI agents (the Agentic Development Lifecycle – ADLC), rebuilding the entire system could be done in three months,“ – says Ackee co-founder Josef Gattermayer.
Source: Martin Topek, Digitalizace stavebního řízení už nikoho nezajímá, práce na ní se v tichosti zastavily, Hospodářské noviny (Czech business daily), 31 July 2026
Contents
- What is the Agentic Development Lifecycle (ADLC)
- Why SDLC stopped working and what the Agentic Development Lifecycle (ADLC) is
- Agentic development vs. vibecoding: what autonomous AI agents mean in practice
- Tools for ADLC: Anthropic tooling for autonomous AI agents
- How to measure agentic development adoption: the PAL and AEPL frameworks
- Concrete goals, not visions.
- Why agentic engineering will affect every developer's competitiveness
- Assessing the success of adoption after 3 months
- Want to bring agentic development and ADLC into practice?
- FAQ
- Sources and inspiration for building parts or all of the framework
ℹ️ TL;DR – what to take away
- The classic form of SDLC is ending – here comes ADLC, where the developer orchestrates agents instead of writing every line of code.
- Agentic engineering requires structure – it's not vibecoding or merged PRs without review. The setup on brownfield projects isn't simple; it all takes a lot of energy, effort and organization.
- Tooling unified on a single platform (Claude) works better than a fragmented mix of tools – a shared knowledge base then makes far more sense.
- Measuring adoption makes sense on 2 axes – the project (PAL) and the individual (AEPL) – both have to go hand in hand.
- Whoever starts sooner gains a lead that's hard to close – and that goes for companies and individual developers alike.
✅ TL;DR – action steps
- Roll out ADLC gradually: start from the very basics with the HITL (human in the loop) technique, doing AI babysitting (observing how the agents behave).
- Work with context: everything stands or falls on which files you reference, what information about the codebase you provide, what you connect.
- Build a shared company foundation for know-how: there's a lot of information and everyone needs to be on the same page.
- Centralize tooling: a unified setup minimizes chaos and speeds up adoption.
- Measure people and projects: PAL + AEPL = a safe rollout.
- Review agent-generated PRs: review and tests are essential = there is no state in which AI gets a completely free hand.
🔚 Why SDLC stopped working and what the Agentic Development Lifecycle (ADLC) is
The Software Development Lifecycle (SDLC) as we know it assumes that a human writes the code. That assumption is questionable today. Enter the Agentic Development Lifecycle = ADLC – where agents plan, implement, test and debug.
- Defines the requirements and works out architectural decisions together with the agent.
- Assembles workflow components such as the verification loop.
- Does the final validation.
"We don't just want to wait and catch up with the competition. We want to be at the front of the pack,"
– says Rostislav Babáček, Team Leader of the Indigo Mobile Development team at Ackee, who designed and presented the whole framework internally.
This isn't dystopia. The point is that the repetitive parts of the work that nobody enjoyed anyway – are taken over by the agent, while the human handles what agents can't: context, decisions, responsibility.
Agentic development vs. vibecoding: what autonomous AI agents mean in practice 🤫
This is exactly what most often gets lost in debates like this: agentic engineering is not vibecoding. It's not "I'll have a feature generated, merge it, and head to lunch." It requires structure, rules and, above all, patience.
It's a process with strict rules, not mindless merging. The developer has to understand what the agent is doing, be able to review the output, and know when to stop the agent. You won't learn that in an afternoon.
We can use the same analogy from the recent past: the iOS team at Ackee also had to come to terms with the arrival of Kotlin Multiplatform. They didn't like it, it hurt – but they took it as an opportunity, not a threat. The whole dev team now needs that same mindset toward AI.
⚒️ Tools for ADLC: Anthropic tooling for autonomous AI agents
Chaos in tooling kills adoption. If half the team is on Cursor, a quarter on GitHub Copilot, and everyone else is trying various Codexes, nobody shares knowledge and everyone reinvents the wheel separately. That's why we unified on the Anthropic platform.
The concrete setup looks like this:
- Claude Code for developers (a CLI tool that works directly in the terminal and IDE).
- Claude Cowork for the back office and project managers.
- Claude Chat as the standard conversational interface.
Why Anthropic and not OpenAI? We needed a single platform for all teams and roles – from devs through QA and design to the back office. On top of that, data from the Ramp AI Index from early 2026 shows that 73.3 % of companies spending on AI for the first time choose Claude – OpenAI has 26.7 %. Anthropic is starting to dominate precisely in the enterprise segment, where consistency and data security matter – and that's exactly what's important to us.
Based on the data, then, we know that OpenAI and Anthropic are the main players who will keep leapfrogging each other. Agonizing over whose models and harness are currently better (when it can be the other way around a month later) only creates chaos and drains energy that should go into the setup. Ultimately, the most important thing isn't the specific model (don't take that too literally), but the overall structure and the established ways of working.
As a bonus, Claude has a cute mascot – the little crab Clawd. And even the biggest skeptics were won over by the fact that Katy Perry has apparently switched to Claude too. And that, of course, is the most authoritative source for us, regardless of the data.
📊 How to measure agentic development adoption: the PAL and AEPL frameworks
So that adoption wasn't punk and a black box, we introduced 2 frameworks that didn't exist anywhere else when we started – we had to build them from scratch. You'll find the sources and inspiration we drew on at the end of the article.
1. Project Adoption Levels (PAL)
PAL is a guide for rolling out agentic engineering on projects and, at the same time, a measurement metric. When we say, for example, that we're going to roll out PAL1 on a given project, developers open the framework, where the points to be implemented are written down, and they follow it through the adoption.
- PAL1: Baseline context and project setup for the agent.
- PAL2: Custom skills, agents, MCP integrations, hooks.
- PAL3: Component orchestration and the agentic loop.
- PAL4: E2E agentic workflows = agents run in an autonomous loop (plan → call tools → test → review).
- PAL5: Sky is the limit! The maximum level, whose definition will shift over time.
2. Agentic Engineering Proficiency Levels (AEPL)
AEPL is a developer's learning path – from the first steps to full autonomy. Each level unlocks the next. It's a shared foundation of knowledge that holds the team together. There's an overwhelming amount of information, we're all swamped, and the AEPL framework tries to sort and arrange it so that developers know how to progress in AI adoption and nobody jumps straight into some super advanced feature, gets needlessly tangled up in it, and misses the fundamentals, security rules, and so on.
A detailed breakdown of everything a developer should master at a given level is written up in an internal Notion, which all developers have access to. Over time, more AEPL levels will of course be added as agentic engineering evolves.
Key rule: For a project to be at PAL1, the developers working on it must reach at least AEPL level 3–4.
The complete breakdown of both frameworks – every PAL level, the full AEPL learning path and the concrete items we roll out on projects – lives in our internal Notion knowledge base. It is not a marketing PDF, it is the material our developers work with every day.
We share it outside Ackee too. If you are working on agentic development adoption in your own team, get in touch and we will open it up for you.
🎯 Concrete goals, not visions.
Frameworks without deadlines are just a nice presentation. That's why, for the opening stage, we have 3 concrete milestones from the start of the adoption, which kicked off here in spring 2026:
- By the end of month 1: All developers have Claude Code up and running, projects are at PAL1, and developers are at least at Proficiency Level 3–4.
- By the end of month 2: A move to PAL2, where AI autonomously handles repetitive tasks and an automated feedback loop is in place.
- From month 3 onward: We're aiming for PAL3 and PAL4 – i.e., a full agentic loop on the largest projects.
"Agents plan. Agents implement. Agents test and debug."
– Rostislav Babáček, Team Leader of the Indigo Mobile Development team at Ackee, who designed and presented the whole framework internally.
Adoption is also measured hard: the Claude Code analytics show who actually uses the tool. License limits can be raised – but only for those who honestly max them out with work.
💡 Why agentic engineering will affect every developer's competitiveness
This isn't just a company initiative. It's a reality that will touch the competitiveness of every individual in the job market. If you blow this change off, you'll lose ground. Companies that don't adopt AI will give higher estimates and lose projects to those that do.
On the other hand: Ackee's goal isn't to replace people. The goal is to make better offers, take on more projects and have fewer regression bugs. Those are things a developer benefits from just as much as the company.
That is what development looks like from the inside at Ackee – the learning path, the shared knowledge base and a team that actually talks about what works. If you are curious how we work, take a look at careers.
At first, AI won't save you that much time in absolute numbers, because the time spent on the processes it takes over shifts into reviewing the outputs – but the higher the initial investment, the higher the return will be after a while.
⚖️ Assessing the success of agentic engineering adoption after roughly 3 months
🌝 The bright side
- We have PAL2 on important projects.
- Some teams are at AEPL6, some at AEPL4, which leads to healthy mutual pushing between teams.
- In both team and individual meetings, the levels are gradually opened up and discussed.
- We introduced a regular AI beer – an informal event where developers swap experiences and share the joys and pains of specific use cases.
- We unified the tooling, which gives us shared marketplaces that developers easily contribute to.
🌚 The downsides
- On large projects there's a context problem. There's more work there than we thought, so we need to build more efficient wikis/documentation and unified glossaries.
- Every week there's a new update in the AI world, which leads to information overload and the need to filter and cherry-pick the important bits.
- Sharing collective know-how between individual teams is a somewhat bigger challenge – keeping everyone on the same page in real time turned out to be harder than we expected.
- Changing the mindset isn't easy at the level of the individual, the teams, or the company.
🔍 Highlights from the internal survey
- More than 80 % of developers see a significant shift in agentic engineering adoption at Ackee, with some feeling the shift as a whole, but the potential is much greater and adoption needs to be evened out across teams and projects.
- Our developers' current feelings about agentic engineering are a mix of enthusiasm, cautious optimism, and motivation to improve, together with a sense of overload and some uncertainty and worries.
- Better coordination and sharing of practices across teams is needed. Without it, work is duplicated needlessly – someone builds a plugin the others don't even know about. AEPL and PAL are seen as the right step here, but the implementation has to be more consistent.
- 100 % of developers agree that unifying on a single tool makes sense. Instead of fragmentation across teams, one shared foundation – Claude.
- Developers report the biggest time savings on implementing larger features and debugging (59 %), and on refactoring and generating tests (45 %).
- The biggest brake on wider adoption? According to developers, it's a lack of time to experiment (55 %) and the early phase of AI coding, where experience is only just forming (41 %).
So we have the inputs for the areas and competencies we want to focus on in team management during the next stage of agentic engineering adoption.
Want to bring agentic development and ADLC into practice?
We're talking about how to bring a similar approach to clients. If you're a company working on a digital product and you're curious what this means specifically for your team or project, 👉 get in touch – we'll be happy to chat about it.
This article came out of Rosťa's internal lightning talk. 👉 Subscribe to the newsletter – you'll get the next piece of content like this straight to your inbox.
❓ FAQ
What is the Agentic Development Lifecycle (ADLC)?
ADLC replaces the classic SDLC in a situation where autonomous AI agents take over the repetitive parts of the development process – planning, implementation, testing and debugging. The developer moves into the role of an architect: they define the requirements, verify the outputs, and bear responsibility for the result.
What is the difference between ADLC and SDLC?
The Software Development Lifecycle (SDLC) rests on the assumption that a human writes the code — the analysis, development, testing and deployment phases are all designed around human capacity. The Agentic Development Lifecycle (ADLC) drops that assumption: implementation and testing are carried out by autonomous AI agents, while the human supplies context, architectural decisions and final validation. In practice the bottleneck moves from writing code to the quality of the brief and the review of the output.
What is the difference between Agentic Development and the Agentic Development Lifecycle?
Agentic development is the practice itself — a developer works with AI agents instead of writing every line of code by hand. The Agentic Development Lifecycle (ADLC) is the whole process framework around that practice: what the individual phases look like, where the human stays in the loop, how adoption is measured and how quality is governed. Put simply: agentic development is what happens, ADLC is how it is organised.
What tools do you need for ADLC?
The foundation is an agentic CLI or IDE wired into the codebase — at Ackee that is Claude Code. On top of that you need a shared knowledge base with project context, MCP integrations into internal systems, custom skills and hooks for repeated workflows, and a tool for back office and project management (Claude Cowork). More important than any single model, though, is getting the whole company onto one platform — fragmented tooling kills knowledge sharing.
How does agentic engineering differ from vibecoding?
Vibecoding is the "I'll have AI generate a feature and merge it without review" approach. Agentic engineering requires structure, rules and control – the developer has to understand what the agent is doing and know when to stop it. One is a shortcut, the other is a discipline.
Why did Ackee bet on Anthropic (Claude) instead of OpenAI?
The key reason was the need for a single platform across all roles – developers, QA, project managers and back office. Consistency and data security in the enterprise segment were essential for Ackee.
What are the PAL and AEPL frameworks?
PAL (Project Adoption Levels) measures what level of agentic engineering a given project is at – from basic context (PAL1) to fully autonomous E2E workflows (PAL4+). AEPL (Agentic Engineering Proficiency Levels) is an internal course and measures the same for an individual developer – from beginner (L0) to Builder & Harness Engineer (L11). Both have to go hand in hand.
How do you introduce agentic development in a company?
Ackee recommends starting with the HITL (human in the loop) technique – the developer watches and corrects the agent rather than handing over work autonomously. Then gradually raise the project's PAL level and the people's AEPL level. The key is to have shared tooling and a knowledge base from the start, not as an afterthought.
🔗 Sources and inspiration
- https://newsletter.pragmaticengineer.com/i/187563524/3-eight-levels-of-ai-adoption + https://steve-yegge.medium.com/welcome-to-gas-town-4f25ee16dd04 section: "WARNING DANGER CAUTION, GET THE F*** OUT, YOU WILL DIE"
- https://www.bassimeledath.com/blog/levels-of-agentic-engineering
- https://www.vellum.ai/blog/levels-of-agentic-behavior
- https://www.youtube.com/watch?v=TUKYbUIXLOE
- https://www.aihero.dev/cohorts/ai-coding-for-real-engineers-m0k0w
- https://code.claude.com/docs/en/overview
- https://www.youtube.com/@anthropic-ai
- https://claude.com/blog
- https://www.anthropic.com
- https://cloud.google.com/discover/what-is-prompt-engineering
- https://www.ibm.com/think/ai-agents#605511093
- https://themodernsoftware.dev - Stanford
- papers from https://arxiv.org
- https://www.aihero.dev
- https://www.humanlayer.dev
- https://www.latent.space/p/2025-papers
- https://newsletter.pragmaticengineer.com
- https://x.com/trq212
- https://x.com/bcherny
