There is a pattern I keep seeing across enterprise teams, vendor pitches, and technology conversations: everyone is talking about AI “tools”. Almost nobody is talking about AI “practices”.
Meanwhile, something significant has been happening quietly. The agentic plugin ecosystem — the layer of structured workflow tooling built on top of AI coding assistants — has reached its “best practices” moment. Tools like claude-task-master (24,000+ GitHub stars), RuFlo (Fortune 500 validated, deployed in 80+ countries), and planning-with-files are not experiments anymore. They are the first generation of systematized, reusable AI workflow infrastructure for individual practitioners. And most organizations are not paying attention to them.
The problem with the current narrative
Enterprise AI mostly runs on two speeds: hype and paralysis. Organizations tell their people to “get AI-ready” while leaving individual contributors — developers, architects, analysts, consultants — to figure it out on their own or to follow a “managed path” for that journey. The commercial message is predictably product-driven: “Adopt Solution A, and you will become AI-ready.”
What is missing is the other half of the equation: processes, practices, methods, and habits.
Here is an inconvenient truth: the people figuring this out fastest are not waiting for a corporate AI strategy. Shadow AI — the use of personal AI tools outside official channels — is not just a compliance challenge (a topic for another day). It is a professional competitiveness reality. In any organization today, colleagues with sharper AI workflows are effectively outcompeting others for the same outcomes. That is not a technology problem. That is a practice problem.
Two things have crystallized from my own research, observation, and experimentation:
There is no “one size fits all.” If your universal answer is “ChatGPT,” you are leaving significant capability on the table. The right tool (or set of tools) depends on the task, the context, and the complexity.
“Everything is Code” is not a sales pitch. Regardless of the role and problem domain — legal research, marketing strategy, financial analysis, project management — AI-generated or AI-assisted code is increasingly part of the answer. That explains why IDEs (in a broad sense, from CLIs to No-Code environments) are becoming a universal command interface.
The AI Capability Space Map
Additionally, the speed of AI evolution (models, tools, players, patterns, practices, etc.) makes it very confusing to know where to invest our efforts, identify relevant alternatives, determine the right direction, or what to do “next”.
In uncertain environments, “clarity wins”. That is why I have organized my personal AI capability into three complementary spaces.
- The Core AI Agentic Space is where the serious productivity work happens: a structured, three-tier framework for progressively complex tasks.
- The Utility & Exploratory Space covers tools like Perplexity for research and Grammarly for quality control — indispensable, but not the primary execution layer.
- The Responsible Data Management Space governs how AI interactions handle sensitive information: Zero Data Retention (ZDR) policies and data anonymization before AI consumption.
These spaces are not silos. They reinforce each other. A well-managed data layer makes the agentic space safer. A strong exploratory space feeds the agentic space with better inputs.
The Progressive Complexity Agentic Framework
The Core AI Agentic Space operates on three tiers, with a simple guiding principle: “keep it simple”. That is, start at the lowest tier that handles the task. Escalate when the ceiling of the current tier becomes visible.
Tier 1 — planning-with-files is the default and handles roughly 80% of daily tasks. Inspired by the “Manus-style” persistent markdown planning pattern, it adds near-zero overhead: a small set of markdown files (task_plan.md, findings.md, lessons.md) and three Claude Code hooks that enforce plan re-reading before key decisions. Setup time: 15 minutes. Token overhead: zero. Cross-IDE portability: universal. The core principle is that the filesystem is memory — plans survive context resets, lessons accumulate manually across sessions, and there is zero vendor lock-in.
Tier 2 — compound-engineering enters when tasks require a structured review cycle, model-aware agent routing, or cross-session knowledge accumulation. Its Plan → Work → Review → Compound cycle and 27 specialized out-of-the-box agents make it the right tool for 3-to-8-hour engineering tasks where output quality and iterative learning matter. Crucially, it is philosophically compatible with the planning habits built in Tier 1 — it formalizes and automates what Tier 1 practices manually. When you adopt it, you remove the Workflow Orchestration cluster from your CLAUDE.md and let the plugin own it, keeping only your lessons file and core principles.
Tier 3 — RuFlo (formerly claude-flow) is the enterprise orchestration layer. Its hierarchical multi-agent swarm — with role-based model routing, SQLite-backed cross-session hive-mind memory, and an immutable audit trail — is the right tool for large-scale, multi-day, parallel, or compliance-sensitive work.
What a structured analysis confirms
After analyzing this three-tier framework against a “silver bullet” approach using other competing agentic plugins over 14 architectural characteristics, my conclusion is clear: this solution has all the ingredients to be scalable, stable, and long-lasting (as much as it can be given the current environment!).
When compared against other major commercial platforms (OpenAI Codex, Google Gemini/ADK, Microsoft Copilot Studio, Manus, Lovable), three structural differentiators emerge:
- The /compound self-improvement loop: to my knowledge and to this date, while commercial IDEs like Windsurf offer passive, auto-generated memory, no competitor ships a deliberate, workflow-phase-driven mechanism — an explicitly named step in the development cycle — that uses agents to actively synthesize session learnings into structured, reusable project knowledge.
- Progressive complexity by design: competitors force a single fixed complexity level. This framework lets practitioners start minimal and graduate to enterprise-grade swarms without changing their mental model.
- Open-source and model-agnostic: every tier is forkable, modifiable, and free of proprietary lock-in.
Why this matters beyond individual productivity
The habits and methods that individuals develop today may become the professional standards of tomorrow. Shadow AI is not going away any time soon — and, in my opinion, organizations that help their people build structured AI practices, rather than just procuring AI tools, will outperform those that do not.
Professionals (inside and outside IT) who have already built these practices are better positioned to do more than be productive. They are positioned to define how AI augments team workflows, what governance means in practice, and where automation is appropriate versus where human judgment is mandatory — particularly relevant in regulated environments.
Where to start
Deploy Tier 1 today. It costs 15 minutes and no money. If you are not yet using Claude Code, the planning discipline — filesystem as memory, plan before acting, capture lessons — transfers to any agentic tool. It is a method, not a dependency.
The AI maturity conversation needs to move on. It is not about which tool to adopt. It is about which practices to develop, which complexity to match to which task, and how to build a capability that compounds over time.
What does your current AI workflow look like for complex tasks — and where does it break down? Do you feel the same tension between technology and practice?