Questions, answered straight.
Aidealy measures developer productivity in a new way: as one R&D workforce of engineers and AI agents, from the work they actually ship.
Here's how it works, what it does and doesn't do, and how it differs from DORA and other engineering metrics.
We also answer the hard questions about fairness and privacy.
Filter the questions below by typing a term.
The basics
Aidealy measures the real productivity of your whole R&D workforce, engineers and AI agents alike, from the work they ship. It connects your engineering activity into one picture that you can question in plain English. You get answers, not another dashboard to interpret.
Developer productivity is how engineers and AI agents contribute to production, for better and for worse. At Aidealy that means:
- What never ships doesn't count, and what breaks production counts against them.
- Productive engineers and agents contribute to production, in volume and in quality.
- They make the most of their IDE working time, lift their team's efficiency and take work end to end.
- Productivity is not how many tokens they consume, lines of code they write, tickets they close or hours they log.
- Aidealy measures each engineer from the code, not from tickets, and ranks them on four signals: code authored, code reviewed, breadth and AI-assisted engineering.
- The ranking is the start, not the end.
- Aidealy doesn't score the business value of the work: we measure the execution; you judge the worth.
SPACE, a well-known framework, also says activity counts should never be used alone to reward or penalize developers. DORA says its delivery metrics are not for comparing individuals, and Aidealy's rank doesn't use them.
Read more: How to measure developer productivity when AI writes code
Because the people who ship your code are no longer only developers.
- Engineers write code alongside AI agents.
- AI agents open pull requests of their own.
- With AI's help, your product managers, UX designers and support engineers push changes to production too.
You need one honest view of everything that whole R&D workforce delivers. Aidealy measures it from the code that ships: what reached production, how good it is, and the bugs that followed. Every contributor, human or AI agent, in one view.
Aidealy is for engineering leaders: CTOs, VPs of Engineering and R&D, and Heads of R&D.
- They use it to see how their teams, and the AI agents working alongside them, are performing.
- It's also for founders and CEOs who want a board-level view of what R&D and the growing AI spend return.
It's built to scale from a focused team to hundreds of engineers.
What gets shipped, and what happens to it after it ships. Aidealy measures:
- The code your engineers and AI agents merge into production.
- The quality of that code.
- The reviews behind it.
- How long the code lasts before it has to be fixed.
- How AI is used in the editor.
Code is the only honest record of what was shipped, so that's what Aidealy measures, not tickets or self-reported status.
Yes. Aidealy measures each engineer, and a team's results are built from the engineers in it. You can ask about one engineer, one team or your whole R&D organization, for example:
- The productivity rank, grouped by team.
- Review times by team.
- What each team uses AI for.
Then ask a follow-up question to focus on one team or one engineer. Teams are the ones you set up in Aidealy, including teams inside departments, so the answers follow your own org structure.
Because tickets are never fully up to date.
- Measuring productivity through the tracker means measuring the paperwork, not the work.
- Code is a record that doesn't depend on how carefully someone updates a status field.
Keep your tracker: Aidealy works alongside it and doesn't replace it. (See “Do I have to replace Jira?” below.)
No. You don't configure dashboards. You don't write queries. You ask. Type a question in plain English and get an answer, with the charts and tables built for that answer. Then ask the next question to investigate further.
How Aidealy is different
A dashboard shows your Git and project data in graphs, and you have to interpret them. Aidealy gives you the answer. You ask a question in plain English, get the answer, and keep asking to investigate further.
A useful one answers the question you have today. In Aidealy you ask it in plain English, for example:
- Which engineers caused the most critical bugs in production last quarter, and who approved them?
- Where is delivery slowing down, and which reviewers keep pull requests waiting longest?
- Which repos improved or declined in code quality this quarter?
You get the answer, with the charts and tables built for it. (See more example questions and answers.)
DORA metrics measure the delivery pipeline. Aidealy measures the engineers and AI agents who do the work.
- Delivery-metrics tools track how fast and how often you ship. That's useful, and Aidealy shows delivery and review timing too.
- Its focus, though, is the quality and lasting impact of what your engineers and AI agents ship, including bugs that appear later.
It shows who and what moves the product forward, not only how fast the pipeline runs.
Read more: Do DORA metrics still work with AI-generated code?
A static analyzer checks code against rules. Aidealy measures your R&D workforce, people and AI agents, from the work they ship. Code quality is one part of that, scored against the full Clean Code discipline:
- Test code and production code are judged separately.
- Scores are tracked over time and across pull requests.
- You see quality per contributor, including AI versus human.
Quality sits next to how long code lasts, bugs, review quality and the overall ranking.
A detector guesses. Aidealy records. An AI code detector scans finished code and estimates, with a confidence score, how likely it is that an AI wrote it. Aidealy records each AI change instead:
- It captures the change from the editor's own record (today, Cursor and Claude Code).
- It pins the change to the exact lines with a content fingerprint.
- It follows those lines through your Git history to what shipped.
A peer-reviewed study of six existing detectors (ICSE 2025) found they perform too poorly to deploy in practice. Other approaches rely on self-reporting, or on one tool's own count of accepted suggestions, which covers that tool alone. When the answer is recorded, there's nothing left to detect.
It is a name for software that collects data from engineering tools and reports metrics on how software gets built. Gartner calls the category software engineering intelligence platforms, and its market guide describes them as tools that:
- Show team activity in dashboards.
- Support metric frameworks such as DORA and SPACE.
Aidealy is built for a different job. It measures your whole R&D workforce, engineers and AI agents, from the work they ship, and you get answers, not another dashboard to interpret.
Trust each for what it can see: system data for what shipped, and a survey for how the work felt. A survey records what developers remember and how they feel about the work. It can't show:
- Which code reached production.
- How good that code was.
- What had to be fixed later.
Aidealy measures those from the code itself, not from self-reported status.
Other tools show you data; Aidealy measures your whole R&D workforce, people and AI agents, from what they ship, and answers your questions.
A prototype is easy now: point an AI at a repo and get a summary. A number you'd base a real decision on is the hard part, and that's the product. It takes four things:
- The AI-usage data. Aidealy's own editor extension captures each AI session in full: prompts, responses, diffs, accepts and rejects, and token use by model. Cursor's API doesn't give that depth at any tier.
- Data an AI can answer from. Pulling Git data is the easy part. The hard work is keeping every commit, pull request, review and AI session in one always-current knowledge graph.
- Repeatable numbers. A one-time AI call gives a different opinion on every run. In Aidealy, the AI judges each rubric and a fixed formula computes the result.
- Methods that take time to build. Aidealy traces a bug found weeks later back to its pull request, author and approver. It measures how long code lasts in production, and ranks people on one score that can be positive or negative.
A prototype proves the idea is appealing. The product is numbers that are accurate, fair and trustworthy enough to show your team. The work is keeping them that way as your code and tools change.
Ask every vendor the same questions, and compare the answers.
- What do you measure from: shipped code, tickets or surveys?
- Does the same input give the same number on every run?
- How do you tell AI-written code from code a developer typed: from records or from an estimate?
- Do you measure AI agents that open and merge pull requests?
- Do you measure each engineer, and who can see that data?
- Where is our data stored, and do you keep our source code?
- Is your pricing published?
Aidealy's answers are on How it works, the Security page and the Pricing page.
The productivity ranking
The Aidealy Productivity Rank is our own fixed formula, not an AI's opinion. Each engineer gets one rank that can be positive or negative, over rolling 7, 30 and 90-day windows. It comes from four signals:
- Code authored: pull requests merged to production (not lines of code), adjusted for their quality impact. Tests and infrastructure-as-code earn extra credit. Code that had to be fixed soon after merge loses credit, and the faster the fix, the bigger the penalty.
- Code reviewed: pull requests reviewed, with size taken into account. Useful comments earn credit. Leaving a review waiting, or approving code that later broke, costs credit.
- Breadth: work across more languages and more repositories.
- AI-assisted engineering: how intensively someone puts AI to work. It's read from editor signals such as running several AI sessions in parallel and the volume of AI interactions. It measures usage intensity, not token spend.
We're open about its inputs, but the exact weights stay ours. A published formula would become the target instead of the work itself, and we keep calibrating it. The rank is computed daily and you get it by asking; a dedicated ranking view is on the roadmap.
Yes to both, by design.
- A rank goes negative when the cleanup someone caused outweighs their output: shipping a lot of code that breaks production isn't productivity.
- A rank also isn't frozen at merge time. When a bug appears later and traces back to a pull request you wrote, or one you reviewed and approved, the penalty applies then.
So a rank can drop weeks after the work was done. That keeps the measure honest, and it's one reason a rank is a signal to look again, never a final verdict.
Because a capped score forces a benchmark, and the right benchmark is different for every team and company. An uncapped rank always leaves room to grow, because continuing to contribute always earns credit. It stays a signal of real impact, not a ceiling someone eventually reaches.
Aidealy doesn't compare you with other companies. It compares your R&D with its own past. What you get is your own trend:
- Each engineer's rank over rolling 7, 30 and 90-day windows.
- Whether code quality is improving or declining, by repo and by team.
A benchmark means something different for every team and company, so the rank doesn't use one. We also don't publish benchmarks or rankings across customers.
It would be, if the number were the final answer. The ranking is where the investigation starts, not where it ends.
- A rank invites you to look closer and ask why someone moved up or down. It's never a verdict on a person.
- Every number in Aidealy is one question away from its explanation.
No. Tokens, lines of code and closed tickets never count toward the rank. Tokens are tracked and you can investigate them, but a token count is a fuel bill, not an achievement. Productivity is measured by contribution to production, in volume and quality, not by raw activity.
Read more: Do tokens or lines of code measure developer productivity?
No. The value of a piece of work is a judgment that changes with context, so no formula can turn it into an honest number.
- A small feature can be priceless when one of your biggest customers is about to leave. The same feature was minor a month earlier, when one of your smaller customers asked for it.
- Experienced leaders in the same room will value the same pull request differently, and that judgment is almost never written down per ticket.
- Value is decided when you set the roadmap, and engineers build what leadership chose. Judging an engineer by the value of the assignment measures your priorities, not their work.
Aidealy measures what it can measure honestly: whether the work you prioritized shipped, how well it holds up in production, and what it cost. We measure the execution; the worth of the work stays with you.
Fairness & ethics
No. Aidealy doesn't watch screens or keystrokes, and doesn't track where anyone is. It measures the work itself:
- The code and reviews that reach production.
- How AI is used in the editor.
- How long people worked in the editor on a pull request (hands-on hours), because that time is part of what the work cost. It's work activity on the pull request, not desk-presence monitoring. Hands-on hours are never used in the productivity rank.
Aidealy doesn't read clipboards or terminals. Managers see signals, not transcripts, and only the people you give access to can see insights about one person. A rank, an hours figure or a sentiment flag is a reason to talk with someone, never a reason to punish them.
Not in the usual sense: hands-on hours belong to a pull request, not to a person's day. They show how much focused editor work a piece of shipped work took, and they're never a timesheet or an attendance log.
- They're recorded from real editor sessions, never estimated.
- They're a minimum. If we didn't capture someone's editor activity, we say unknown, not zero.
- They cover work on the pull request, not desk presence or where anyone sits.
- They never count toward the productivity rank.
They're on your engineers' side, too. A pull request a bot opened no longer looks like zero effort, and the person who finished it finally gets credit for their real hours.
Aidealy doesn't make that choice; leaders do. We built it for understanding and support. Use it to:
- Find where help is needed.
- Make AI's impact visible.
- Start better conversations.
The ranking is the start of an investigation, not an automatic judgment. Used as a tool for forced rankings, any measurement system causes harm. That's why every number in Aidealy is framed as the start of a question, never the answer.
That's why Aidealy measures shipped production code, not numbers that are easy to inflate.
- Lines of code, closed tickets and token usage can all be inflated, so none of them count toward the rank.
- Code that lasted in production and didn't have to be fixed is much harder to manipulate.
- Because the rank subtracts for rework and bugs, adding volume only to raise your number works against you.
Read more: Which developer productivity metrics should you never use?
No. How much someone prompts the AI isn't productivity, so it's only a minor signal.
- AI did change how engineers work: the strongest now run several AI sessions in parallel rather than one at a time. Aidealy makes that new way of working visible.
- What reaches production, and its quality, dominates the rank, so opening extra sessions or sending more prompts barely moves it.
- A flood of messages can even mean someone is stuck, and that shows up as sentiment, not as a reward.
Aidealy doesn't collect screens, keystrokes, clipboard, terminal output or physical presence at all. Some other things are visible but never count toward the productivity rank:
- Tokens consumed.
- Lines of code.
- Closed tickets.
- Raw hours logged. Hands-on hours are recorded, and you can ask about them as the cost of a pull request (see Data sources & coverage). They never count toward the rank.
What counts is impact on production, in volume and quality, for better and for worse.
The rank rewards more than writing code. It's measured over rolling time windows, and careful review, breadth across languages and repositories, and taking work from start to finish all count. It's designed so that the engineer who quietly reviews well and prevents bugs is recognized, not only the one who merges the most.
Because how hard a task feels is an opinion, not a measurement. A task that takes one engineer a week can take another an afternoon. Hard work does leave traces that can be measured, and the rank already counts them:
- Hard work tends to span more repositories and more languages, and breadth is one of the rank's four signals.
- A hard problem solved well shows up as code that lasts in production, which earns more than code that had to be fixed.
A rank built on how hard tasks feel would reward whoever describes their work as the hardest. Every pull request also shows its hands-on hours and its token bill. They show what the work cost, never what it was worth.
Code quality
The Aidealy Code Quality Score is our own scoring formula. It scores your source code against the entire Clean Code discipline, not only complexity or lint rules. Aidealy also:
- Scores test code separately from production code.
- Tracks how the score moves over time and across every pull request.
- Shows the score per file and per contributor, including AI-written versus human-written code.
Every rubric counts, and the results combine into one score from 0 to 100. The AI judges each rubric on its own, and a fixed formula then computes the final score, so the result is repeatable.
The AI's job is narrow, and the math isn't its job at all.
- The AI judges each rubric on its own: naming, function size, error handling, duplication and so on.
- Then code computes the final score from those judgments with a fixed weighted formula.
The LLM judges; code scores. That split is what makes the result repeatable instead of a one-time opinion.
Because good test code and good production code follow different rules. The Clean Code discipline itself makes this split:
- Production code is judged on one set of principles.
- Test code is judged on what makes tests trustworthy: fast, isolated, repeatable and self-validating.
Scoring them together would punish good tests for not looking like production code, and the other way around.
Whether your code quality is getting better or worse. Because the score is tracked across every pull request over time, you can ask about direction, not only a snapshot. For example:
- Is our code quality improving or declining this quarter, by repo and by team?
- Is AI-written code holding up as well as human-written code?
It's a rigorous, consistent judgment, not an absolute truth.
- It's grounded in a well-known discipline and scored by one method applied evenly to every file and every contributor, with no favorites.
- It reflects code-quality principles, not a law of physics.
- The method is versioned and improves over time, so scores are comparable within a methodology version, never guaranteed across versions.
Treat it as a reliable signal to investigate, like everything else in Aidealy.
Bugs, longevity & severity
A critical bug is code that had to be fixed within 7 days of reaching production. The faster merged code has to be corrected, the more serious the problem it caused. So Aidealy uses how quickly code needed fixing as its measure of severity.
A commit reaches production when it's merged into a repository's default branch. Aidealy works this out from your Git history alone, and it never accesses your production environments, resources or logs. When production code gets fixed, Aidealy traces the fix back through your Git history, even weeks later:
- It finds the pull request that added the original line.
- It ties the bug to the engineer who wrote that line and to the reviewer who approved it.
- You can then ask Aidealy to rank the engineers whose code broke production the most last quarter, and the reviewers who kept approving that code.
Only production code counts. Changes made while a pull request is still open are left out, so no one is penalized for improving their work before it merges. Coming soon You'll also be able to define production in other ways, such as release tags or a specific branch.
Because review is where quality problems should be caught.
- With AI, code is written faster than ever, and careful review is the new bottleneck.
- Holding only the author accountable ignores half of how bugs reach production.
Seeing both the author and the approver makes review visible and valued.
Read more: Who is accountable for bugs from AI coding agents?
Measure what happened to the code after the reviewer approved it. Aidealy measures review quality and review speed from your Git history:
- When production code has to be fixed, Aidealy traces the fix to the pull request, its author and the reviewer who approved it.
- In the productivity rank, a reviewer earns credit for useful comments.
- Leaving a review waiting, or approving code that later broke, costs credit.
- Review speed has three numbers: time to first review, time to approval and time to merge.
By how long the code lasted before it had to be fixed.
- Code fixed within the first day carries the heaviest penalty.
- The penalty gets smaller at 7, 30 and 90 days.
- Code that lasts 90 days or more carries no penalty.
Each pull request that introduced a bug is counted once. The penalty is also capped, so one bad merge can't lower a rank without limit.
No. Aidealy doesn't read your tracker or depend on how a ticket was labeled.
- It finds corrections straight from your Git history: code that had to be changed soon after it shipped.
- So the signal is the same whether or not anyone opened a ticket.
It's one more reason measuring through tickets doesn't work well: the evidence is in the code, not the paperwork.
Fair point. Aidealy doesn't decide whether it was a bug or a feature; it measures whether the code lasted. If code shipped to production and was removed or rewritten within days, real effort went into work that didn't survive. That's a cost, whatever the ticket called it:
- A defect.
- A rushed feature.
- A change of business direction.
The signal comes from your Git history, not from anyone's opinion of the change. A rank is a starting point, not a verdict. So the reason is what you investigate next: a planned change of direction, or a quality miss.
Neither. Aidealy measures what happened. It doesn't predict bugs or read your incident reports. It measures corrections in your Git history as a sign of where production code didn't last: what shipped, and what had to be fixed.
Aidealy measures it on your own code, for code written in Cursor or Claude Code. It works like this:
- Every line changed in a pull request that merges to your production branch is labeled AI-written or human-written, from the records those tools keep.
- Aidealy then measures how long the code lasts before it has to be fixed.
- So you can ask how much of your code is AI-assisted, and whether it's linked to more rework after merge.
Humans + AI agents
It means Aidealy treats autonomous AI agents as contributors: their code is scored and their bugs are traced.
- These agents open pull requests, review code and even merge on their own.
- They're a real, automated part of how software gets built, separate from the AI assistant your developers use inside their editor.
So you see your agents' quality and impact the same way you see your engineers'.
For work that comes through Git, Aidealy detects whether a contributor is a bot or a person.
- An autonomous agent that opens, reviews or merges pull requests is measured as its own contributor, kept apart from people. This is about agents acting as contributors.
- AI-written code inside a developer's editor is a separate question.
See “How does Aidealy tell AI-written code from what a developer typed?” under Data sources & coverage.
One. An agent is identified by its Git identity, not by how many copies are running.
- Its Git identity is the user it commits and opens pull requests as.
- It's like a human engineer pushing from two laptops: still one Git user, still one person.
However many copies run in parallel, Aidealy measures them as the single contributor they act as.
No. A bot has no editor, so it has no hands-on hours.
- Its number is always zero, which is different from a human's “unknown.”
- A bot is measured on the code it produces, and its lines sit in their own bucket, never counted as human hand-written work.
- When a person takes over a pull request a bot opened and finishes it, that person gets full credit for their real hours. The work doesn't look like zero effort just because a bot started it.
Start by separating cost from value.
- The cost side is what you spend on AI, which Aidealy tracks by model and by engineer. Spend is context, never the measure of worth: a token count is a fuel bill, not an achievement.
- The value side is whether AI-assisted code lasts in production as well as human-written code, or creates rework. Aidealy measures the quality and longevity of what ships, and separates AI work from human work.
So “Are we getting value from AI?” becomes a measured answer per team instead of a debate. Just ask.
Compare the code your team wrote with AI and the code it wrote by hand, after both reached production. Aidealy records which lines came from Cursor or Claude Code, from the tools' own records, so you can ask:
- For code written in Cursor or Claude Code, how much is AI-assisted, and is it linked to more rework after merge?
- How does AI-written code quality compare to human-written?
- What is each team using AI for: debugging, planning, documentation, tests or security?
- How much are we spending on AI, by model and by engineer?
Review times show the other side. With AI, code is written faster than it can be reviewed, so the wait has moved to review.
Show them three things, all measured from the work itself:
- The cost: token spend by model and by engineer, and what a merged pull request cost in tokens.
- The outcome: what shipped, its code quality and whether it lasted in production, for engineers and AI agents alike.
- The bottleneck: where delivery slows down now, so the next dollar goes where the wait is.
Aidealy doesn't turn that into a single ROI score, because value is a judgment made when you set priorities. We measure the execution; you judge the worth.
Data sources & coverage
Three sources today: your Git provider, Cursor and Claude Code.
- Your Git provider (GitHub, GitLab, Bitbucket or Azure DevOps): commits, pull requests, reviews, approvals and review requests, with bot-versus-human detection.
- The Cursor editor extension: AI-assisted coding, including prompts, responses, diffs, accepts and rejects, and token usage per session by model.
- Claude Code: the same AI-assisted coding signals from your developers' Claude Code sessions.
Down to each prompt. Aidealy looks at AI activity per prompt, which is finer than a whole session.
- It also records which branch the files were changed on at the time.
- From there it follows your Git history forward.
- That branch's commits belong to the pull request that merges them.
So an AI interaction in the editor is connected to the pull request it ended up in. (Linking to the matching issue-tracker ticket is on the roadmap.)
From records, not guesses. When a developer uses AI in Cursor or Claude Code:
- Aidealy captures each AI change from the tool's own record of it.
- It pins the change to the exact lines it touched with a per-line content fingerprint.
- Indirect changes count too: if the AI runs a script that edits other files, those changes are attributed to AI as well.
There's no statistical detection and no confidence percentage.
Yes. Every line changed in a pull request that merges to your production branch is accounted for. For the code your people committed, the label is AI-written or human-written, and the rule is deterministic:
- Each shipped line is matched by its content fingerprint against the AI edits Aidealy recorded from the editor. A match means AI; no match means hand-written by the person who committed it.
- If both touched the same line, the version that ships decides. If a developer rewrote the AI's line before the merge, the line is theirs. If the AI's line shipped untouched, it stays the AI's.
- The fingerprint is a one-way hash. It can't be turned back into code, and Aidealy doesn't retain your source.
- A line is labeled AI from the records your AI coding tools keep (Cursor and Claude Code): real evidence, never an estimate.
Autonomous AI agents that commit under their own Git identity are measured separately, as contributors in their own right. Their lines sit in their own bucket and never count as human hand-written work. See “Humans + AI agents.”
Yes. We call it the pull request's hands-on hours. For every pull request, Aidealy records the focused editor work behind it, in hours per contributor:
- Hours are recorded from the editor, never estimated. They're a minimum, never a full count.
- Each editor session is connected through your Git history to the pull request it became.
- Hours are person-hours, not elapsed time: two engineers pairing for an hour is two hours of effort.
- They're the cost of the work. Hands-on hours never count toward the productivity rank.
Cycle time measures how long a pull request waited; hands-on hours measure how long people actually worked on it.
They include the editor sessions Aidealy can match to a pull request, by repo, branch and time window. They don't include:
- Meetings, code review, whiteboard sessions or thinking time away from the editor.
- Work done in editors Aidealy doesn't capture.
So the number is a minimum, not a full count of everything a person did. Where we have no editor activity for someone, we show unknown, never zero.
Gross is all the active time in your editor sessions, including stretches where the AI is working. Net counts only the stretches around your own messages. So net reflects your own hands-on work.
- Net isn't a tool for watching breaks: a short grace window keeps the first part of any pause, so stepping away to think still counts.
- Net is there for fairness: a lunch break left running in the editor never inflates anyone's number.
For each person credited on a pull request, you see:
- Their hours and sessions.
- Their commits, and the lines they added and removed.
- Their AI-assisted versus hand-written lines.
- The AI models they used, and token usage per model.
Effort is credited to the people who wrote the code: the pull request's commit authors and whoever opened it. Reviewers and commenters aren't part of the hours, because these are hours of work in the editor, not review time. And because they're person-hours, two engineers pairing for an hour show up as two hours of effort.
Aidealy supports Cursor and Claude Code today. For Cursor, add the Aidealy extension from Open VSX: EU edition or US edition, for the region where your company's Aidealy data is kept. We'd be glad to discuss other editors with our customers.
No. Aidealy doesn't require a Cursor Enterprise license.
- It doesn't use Cursor's API.
- It captures AI usage through its own editor extension, which installs like any other extension.
- There's no enterprise tier to buy and no admin API access to grant for Aidealy's sake.
- Using Aidealy doesn't require upgrading your team's Cursor plan.
If you already run Cursor Enterprise for other reasons, Aidealy works with it too.
They show raw usage metrics for each tool. They give no insight into what that code did after it shipped. Each covers its own tool only, and none of them shows:
- How AI-written code quality compares to human-written.
- How long the code lasts in production before it has to be fixed.
- Which pull request, author and reviewer a later bug traces back to.
- Cursor, Claude Code and the code your engineers typed, together in one view.
Aidealy measures all four.
No. Keep your tracker: Aidealy doesn't replace it. Our point is narrow: don't measure productivity through tickets that are never fully updated. Issue-tracker integration is on the roadmap, so one day you'll be able to ask questions that span your tracker too. Coming soon
Yes. Ask “Who's slowing down delivery?” and Aidealy ranks engineers and teams. It uses review timing from your Git history:
- Time to first review.
- Time to approval.
- Time to merge.
With AI, code is written faster than it can be reviewed, so the bottleneck has moved to review. The wait now has a name and a number.
AI conversations & focus
Yes. Every AI-assisted session is classified three ways:
- By area, such as backend, frontend, infrastructure, tests or docs.
- By purpose, such as planning, debugging, writing tests or fixing bugs.
- By the concerns raised along the way, such as security, performance, cost or compliance.
So you can ask what each team uses AI for, not only whether they use it.
It's sensitive, so we treat it carefully.
- The data comes only from AI-assistant conversations in the editor: work conversations engineers already have with a tool.
- It doesn't come from private messages, personal accounts or anything outside the AI coding workflow.
It's access-controlled, governed by our Privacy Notice, and meant for support and understanding. We never present it as a way to find fault with people.
Security & privacy
We don't retain your repository source. Aidealy reads your Git history through short-lived access. Data from the editor extension, including the prompts and diffs you choose to share, is handled under our Privacy Notice.
It's the right question. Our approach is to hold as little as possible, isolate everything we process and encrypt all of it.
- We don't keep your source. Aidealy reads your Git history through short-lived access and doesn't retain your repository source. We keep the derived metrics, not your code.
- Each customer is strictly isolated. Your data, your encryption key and your AI-provider key are dedicated to your tenant and can't be used by any other customer. Every workload runs as a single-tenant execution (details in “How is my data kept separate?” just below).
- Your code and prompts aren't used to train AI models. Aidealy doesn't train on them, and our AI providers are contractually committed not to train on our customers' content.
- Your data is stored in your region, encrypted and governed. You get EU or US residency with no cross-region replication, encryption in transit and at rest, and role-controlled access. Our security, privacy and AI-governance program is designed to meet SOC 2, ISO 27001, ISO 42001 and GDPR requirements.
See the Security page for the full technical detail.
Isolation is how every tenant is built, with dedicated resources for each customer.
- Your data lives in its own per-tenant stores, encrypted under a key unique to your tenant. That key can never unlock another customer's data.
- Your AI calls run under a dedicated AI-provider key that no other customer uses.
- Every workload runs as a single-tenant execution that can reach only your data and keys.
- Row-level security protects your core records.
Full technical detail is on the Security page.
Not yet. Aidealy provisions both keys for you, one set per tenant. Your tenant gets a separate encryption key and a separate AI-provider key, unique to your tenant. The isolation is real; the keys are ours to manage per tenant.
You choose your data residency: EU or US. Your data is stored in the region you pick, per tenant, with no cross-region replication.
Our security, privacy and AI-governance program is designed to meet SOC 2, ISO 27001, ISO 42001 and GDPR requirements. When we're certified, we'll say so, with the report to back it. We don't display certifications we don't hold.
Only the people you give a named chat seat to can query Aidealy and see the data. The engineers you're measuring don't have access. Aidealy is built for your engineering leadership, and each seat belongs to a specific person on your team.
- The product has no view for engineers.
- An engineer sees an insight only if a seat-holding leader chooses to share it with them directly, in a conversation, not through Aidealy.
- Sensitive signals about one person, such as sentiment or what someone is working on, stay with the seat-holding leaders. They're never broadcast across your org.
A rank or a flag is a reason to talk with someone, not a feed for the whole company.
Getting started
Talk to us. Onboarding is hands-on:
- We connect your Git provider and set up Aidealy in Cursor and Claude Code for the teams you want to include.
- We also provision your isolated environment in your region.
Then we show you your own R&D: your engineers, your AI agents and the code they ship together.
Your Git provider (GitHub, GitLab, Bitbucket or Azure DevOps) for the work that ships, and Aidealy in Cursor or Claude Code for AI-usage signals. That's enough to start measuring.
Setup is light, and we do it with you. Four steps:
- Connect your Git provider in the Aidealy admin web app.
- Install Aidealy for your developers: the extension in Cursor, and a small background program for Claude Code.
- Wait up to 24 hours while Aidealy loads your history (the backfill). By default it loads one year of Git history; a longer backfill is a paid add-on.
- Start asking questions in plain English and explore the answers.
There are no dashboards to configure and no queries to write. Once your history is in, you just ask.
Your Git history already holds the baseline. Aidealy's backfill can go back to the time before your team started using AI tools, and loads:
- Your past Git history, with code-quality scoring.
- Your engineers' Cursor and Claude Code history, as far back as each engineer's machine keeps it.
So the time before AI is measured the same way as the time after. (See the Pricing page for how far back the backfill goes.)
No. A subscription starts with your history loaded, and the 30-day money-back guarantee is how you evaluate Aidealy on your own data. To see the product first, ask for the free demo: the real Aidealy chat app on a fictional company's data.
The real Aidealy chat app, on a fictional company's data. You ask questions like these in plain English and judge the answers yourself:
- Rank the most productive engineers in the last 30 days.
- Do pull requests with more AI-written code have lower code quality?
- Which reviewer was the biggest approval bottleneck in the last 30 days?
- Which repositories improved or declined in code quality over the last 90 days?
We review every request by hand, and access lasts 7 days, with more time on request. To ask your own questions, request demo access.
Our pricing is published in full, with no quote required. The Pricing page shows:
- The monthly price for every seat type (human engineer, AI agent, Chat, Admin).
- The volume discounts that apply automatically as your team grows.
- The one-time backfill that loads your history.
- A calculator that prices it all for your own team.
If you'd rather walk through it together, talk to us.
Because every Aidealy account starts with a backfill of your history, so you get real answers from the first day. A free tier would either skip the backfill and show an empty screen, or give it away before we know your team is a fit. Instead, there's a 30-day money-back guarantee:
- You start on your own R&D, fully set up.
- Your seats are refundable in full if Aidealy isn't a fit.
To see the product first, ask for the free demo. To start on your own R&D, talk to us. (See the Pricing page for the model and the guarantee.)
There's a 30-day money-back guarantee. If Aidealy isn't a fit within your first 30 days, we refund:
- 100% of your seat charges: human engineer, AI agent, Chat and Admin.
- 50% of your one-time backfill, whether you loaded one year of Git history or three. The backfill is half-refundable because it loads and enriches your entire purchased history up front, so that work is already delivered.
Seats flex with your team, up and down: each month's bill reflects that month's peak number of active seats, counted per seat type. All terms are governed by our Terms of Service and Refund & Cancellation Policy, and we'll walk you through them before you start. (See the Pricing page for the full model.)
Still have a question?
The best way to understand Aidealy is to see it in action. Talk to us and ask us anything.