Getting the most out of AI is an iterative journey. It takes more than good tooling. It takes a mindset: a team willing to experiment, fail without fear, share what they learn, apply those insights, and keep improving. That's exactly what our AI Circle has been doing to drive AI enablement across Engineering, helping teams learn from one another and turn experimentation into tangible progress. Five months in, the picture is getting clearer and so is the list of things we got wrong the first time.
Our context: what is Ataccama actually doing?
Ataccama builds data management and data trust agentic platforms. Powered by AI agents, our software helps large enterprises govern, understand, and trust their data at scale, without expecting users to be data experts.
Our product is Ataccama ONE, an agentic data trust platform that brings together data quality, observability, lineage, governance, and master data management in one solution. That's a lot to bring together in a single platform. Building something this sophisticated means our engineers get to wrestle with genuinely hard problems every day, which is exactly the kind of challenge that makes coming to work interesting.
For the past year we've been not only watching the AI coding wave arrive, but decided to get systematic about it.
What Is the AI Circle?
The AI Circle is an internal engineering community we established to do one thing: reinvent how software gets built at Ataccama using AI agents.
The goal isn't modest. We're building our own deterministic agentic harness to ensure consistent results with high standards of code quality, maintainability, and security across all roles.
We're deliberately starting with a narrow scope. The Circle focuses on the developer part of the SDLC: the software development lifecycle, from a task landing in the backlog to a change merged and deployed, before expanding to other parts of the organization. We'd rather genuinely solve one problem than superficially touch ten.
The Circle doesn't work in isolation. It's one thread in a broader, coordinated push across Ataccama to bring AI into how we build and support software, but its mandate stays specific to the developer workflow.
In practice, the Circle does three things:
- Evaluates and adopts tools: running structured proofs of concept (PoCs) on AI coding assistants and agents, and making honest decisions about what to keep and what to pass on
- Driving enablement: for the entire engineering organization to leverage AI, by developing guidelines, standards, and tooling that help every team benefit, not just the ones with an enthusiastic individual experimenting in isolation
- Knowledge sharing: actively mentoring teams to bridge gaps, standardize documentation and workflows, and level up our collective engineering proficiency with AI
Everything the Circle produces is shared transparently. All outputs: evaluations, guidelines, meeting notes are internally public.
Our journey: key takeaways
The AI Circle launched in late February 2026, and we already have plenty of learnings to share. Here's what we've done since, including the newest developments from the past few months.
Setting up foundations
Since launching in February 2026, we've learned that the biggest friction isn't code generation, it's verification and trust. We've moved from viewing AI as an individual tool to an organizational capability, focusing on codebase readiness and validation. We also learned when to say no: after a structured PoC, we decided not to adopt Augment Code, choosing instead to develop internal capabilities like Suri, our own custom agent, that better fit our specific needs.
Defining focus areas
After running two structured internal workshops to map our AI assisted development workflows and identify bottlenecks using a "How Might We" format, we landed on three focus areas:
- Codebase readiness for agents. The biggest bottleneck we kept seeing: agents pick wrong patterns when there's no clear guidance in the codebase. AI is good at mimicking existing code. So giving it good examples to copy from is high leverage. This drove our work on repository guidelines.
- Automating learning and continuous improvement. LLMs have no memory between sessions. We started exploring ways to capture session learnings, extract patterns from code reviews, and build per repo memory so agents get smarter over time rather than starting from zero.
- Proof of work and validation. Moving from "the agent says it works" to concrete proof: tests, recordings, contract checks. Test driven development first flows, hook enforced test writing, cross agent reviews.
Making repos AI ready
We were working on finalizing the repo guidelines we first drafted and shipping a CLI utility to make adoption as painless as possible.
This might sound like housekeeping. It isn't. It's about creating an infrastructure.
As we explored in an earlier engineering post, Teaching AI Agents to Understand, Not Just Code, the difference between an AI agent that generates code and one that genuinely reasons about a system comes down almost entirely to context. An agent that understands your architecture, your conventions, your dependency graph, and your team's accumulated decision history is categorically more useful than one that only sees the file in front of it.
The repo guidelines create that context: consistently, across every repository in the engineering organization.
What the guidelines actually give you: Every repo following the harness gets an entry point file (AGENTS.md) that acts as a routing table. This gives each repo and thus humans and agents a shared baseline of verified skills, workflows, and docs that work, providing a consistent structure for navigating any Ataccama repository. The real substance sits in a docs/folder: coding guidelines, runbooks for common procedures, short architecture decision records, and a friction log tracking patterns that have cost agents time before.
This gives agents the context to produce code that actually fits not just syntactically, but structurally. The second layer is more interesting: turning sessions themselves into documentation. Agents have no memory between conversations, every session starts from zero, which means every non-obvious discovery risks being lost. We've addressed this with a learning loop built into the harness: a compound skill that captures patterns, friction points, and discoveries - to a session scratchpad during work, and a reflect skill that at the session's end, promotes the valuable ones into the right docs files: a new guideline, a runbook update, a note about where the code is hard to work with. The scratchpad clears. The next session starts with a slightly richer codebase than the one before.
We're rolling this out across repos now. It's too early to report hard numbers, but the direction is clear: each session should leave the codebase a little smarter than it found it and those gains should compound. We've also started laying the groundwork to actually measure that instead of relying on gut feel: a lightweight way to track which skills get used and where agents still struggle, so the next round of investment goes where it's genuinely needed.
Getting your repo ready: we built a CLI utility that handles most of the setup as a one time operation, aimed at making any future updates painless and easy for the team.
A few honest expectations: this isn't a magic fix. It's a baseline - a consistent starting point from which we can iterate. It's the first version and not perfect, and we want feedback. The point is to give the entire engineering organization a shared foundation, not to achieve uniformity for its own sake.
We're also starting to connect this work with Suri, our first fully custom AI agent: the idea is to let good skills flow in both directions - reusing shared skills inside Suri, and promoting Suri's best skills back out to the wider marketplace once they've proven themselves under a higher-quality bar. It's early days, but it points at where we want this to go: one shared, improving set of building blocks instead of parallel efforts that never talk to each other.
Scaling knowledge sharing and mentoring
Beyond tools and guidelines, we've prioritized intentional knowledge sharing to help our engineers use AI more efficiently and confidently. We run a cross team mentoring program where power users of our AI agents work directly with teams to address specific requirements and challenges. This hands on support helps teams:
- Kick off new projects
- Ensure proper repository setup
- Demonstrate workflows that integrate seamlessly with agents
- Level up other engineers
- Share knowledge across teams
What started as a single conversation has become a running program. Teams now come to the Circle with a prioritized list of their own questions and problems. We assign a small pool of AI power users, at least three, drawn from across different teams and run a focused, one hour session built around exactly what that team needs, with as many follow up sessions as they want.
One concrete example: our AI coding tools' permissions model was causing real friction for certain workflows, and we're now looking into how to work around it. Since then, other teams have started reaching out to book sessions themselves rather than waiting to be scheduled, which is exactly the outcome we were hoping for: knowledge sharing that sustains itself instead of depending on the Circle pushing it out.
Key takeaways for any engineering team that wants to learn from our experience, and things worth your time if you're working with AI coding tools:
- Mine your own history: your past sessions and merge requests are full of repeated mistakes and corrections that never made it into documentation. Asking an agent to review its own recent sessions, or a few months of review comments, and turn the patterns into repo docs is one of the highest leverage, lowest effort things a team can do.
- Monitor your token usage: tracking token counts in active sessions helps identify context degradation early, preventing output quality issues before they arise.
- Optimize output formats: while markdown is common, consider using HTML for AI generated output in specific contexts to improve structure and readability.
- Deepen your understanding of agentic skills: familiarize yourself with how agentic skills are structured under the hood; understanding these mechanisms is crucial for building robust and effective AI driven workflows.
- Align AI strategy with Ataccama product goals: focus on practical frameworks that bridge the gap between AI capabilities and product management workflows to drive meaningful engineering outcomes.
What's next? Turning experimentation into evidence
A few things we've picked up in the past few weeks are less about new tools and more about growing up as an initiative.
We're moving from anecdote to evidence. Enthusiasm and word of mouth got the Circle this far, but it's hard to know where to invest next without data. We're piloting lightweight usage tracking for our agentic skills: what gets used, what doesn't, where agents still struggle, using the observability tooling we already have rather than building something new.
We're also looking at reliability in a very practical, unglamorous way: piloting dedicated AI access for people on incident response, so an engineer on call doesn't run out of AI budget in the middle of resolving an incident. It's a small operational change, but exactly the kind that matters at two in the morning.
And the Circle may start growing itself. We're considering opening membership beyond the founding few to active power users who've stood out through the knowledge sharing sessions, turning some of the best contributors from those one hour sessions into Circle members themselves. Nothing is decided yet, but it's the direction we're leaning.
Note
Ataccama builds data management and data trust platforms for large enterprises. Our engineering blog covers the real technical and organizational challenges of building and operating complex software systems. If you're interested in how we work — or in working with us — visit jobs.ataccama.com.