Blog
LGTM meaning, and how to give an LGTM that counts
Where LGTM shows up in code review and chat, the other LGTMs people search for, and what to check before you type it.
Alex Mercer
LGTM stands for "looks good to me." In code review, it means the reviewer approves the change, and in chat it's a quick yes to a plan, a draft or a message.
LGTM is also the name of Grafana Labs' observability stack and of LGTM.com, a code analysis site that shut down in 2022.
LGTM meaning, with examples
Google's engineering practices guide defines it in one line: LGTM "is what a code reviewer says when approving a CL." A CL, or changelist, is roughly a pull request.
Most of the time LGTM means approve. Sometimes it comes with small asks ("LGTM, two nits"), and in chat it can just mean yes.
At Google, an LGTM is one of three approvals every change needs. Software Engineering at Google lists a correctness and comprehension check from another engineer (the LGTM), approval from a code owner, and approval from someone with "readability" in the language.
Where LGTM is used
Pull requests on GitHub and GitLab
On GitHub, a review ends with Comment, Approve or Request changes. GitHub describes Comment as feedback "without explicitly approving or requesting changes," so a comment that says "LGTM" is not an approval. When a branch requires approving reviews, only an Approve from someone with write access, or from a designated code owner, counts.
GitLab merge requests have an Approve button and an /approve quick action. Approvals are optional on GitLab Free, and Premium and Ultimate can require them.
Gerrit, Chromium and Kubernetes
Some systems turn LGTM into a formal vote. Gerrit's default Code-Review label spells it out: +1 is "Looks good to me, but someone else must approve" and +2 is "Looks good to me, approved." In Chromium, which also uses Gerrit, a Code-Review +1 is "also known as an LGTM," and a change needs one from an owner of each directory it touches.
Kubernetes splits the job with bot commands. A reviewer comments /lgtm, an approver from an OWNERS file comments /approve, and a bot merges the PR once it has both labels, no hold and passing tests. Authors can't /lgtm their own PRs (Kubernetes OWNERS guide).
Where | How a reviewer says LGTM | What it takes to merge |
|---|---|---|
GitHub | An Approve review | The approvals your branch rules require, if any |
GitLab | Approve button or | Optional on Free; approval rules on Premium and Ultimate |
Gerrit | Code-Review +1 or +2 | A +2 on the latest patch set and no -2 |
Chromium | Code-Review +1 | A positive review from an owner of each directory touched |
Kubernetes |
|
|
Chat and email
Outside code review, LGTM means the same thing at lower stakes: you've read what was sent and you're fine with it. It's informal, so with people outside engineering, write "looks good to me" in full.
The other LGTMs
Grafana's LGTM stack
In observability, LGTM is Grafana Labs' stack: Loki for logs, Grafana for dashboards and visualization, Tempo for traces and Mimir for metrics. Grafana's docker-otel-lgtm project packs an OpenTelemetry Collector, Grafana, Loki, Mimir and Tempo into one Docker image, meant for development, demo and testing environments.
LGTM.com
LGTM.com was Semmle's code analysis site for open source projects. GitHub announced in September 2019 that Semmle was joining GitHub, and the analysis engine behind LGTM.com went on to power GitHub code scanning. In August 2022, GitHub announced that LGTM.com would stop taking new sign-ups at the end of that month and shut down on December 16, 2022. The domain now redirects to that announcement.
When an LGTM is a rubber stamp
A rubber-stamp LGTM is an approval without a review behind it. It still satisfies the branch rules, so the code merges as if someone had read it.
The diff is too big to read
Google's guide on small changes says "100 lines is usually a reasonable size for a CL, and 1000 lines is usually too large," and lets reviewers reject a change for its size alone. A Microsoft Research study of 1.5 million review comments found that the more files a change has, the lower the share of comments that are useful to its author. If you can't hold the change in your head, ask for a split instead of approving it.
The approval came in seconds
Look at the timestamps. Nobody reads a large diff in the seconds between a PR opening and an approval landing. Google's reviewer guide asks reviewers to look at every line they've been assigned, and to ask the author to clarify code that's too hard to read before reviewing it.
Nobody read the AI-written code
At Google, a growing share of the code reviewers approve is written by AI. In April 2026, CEO Sundar Pichai wrote that "75% of all new code at Google is now AI-generated and approved by engineers, up from 50% last fall."
When an agent wrote the change, the author may have skimmed it too, so the review can be the first time a person reads every line. AI-written code also fails in its own ways, such as code that compiles and reads cleanly but breaks an unwritten rule of your system (more in why AI code fails differently).
Bug Bench, our public benchmark, counts a bug when a developer upvotes a cubic code review finding on AI-written code or an AI coding agent addresses it. In its current ranking, relative bug rates for the 7 ranked models run from 0.65 to 1.50, where 1.00 is the average rate across all AI-attributed lines. Every ranked model has counted bugs. The data is observational: teams choose their models, so a rate reflects the code each model was used for as well as the model.
The LGTM is older than the code
An approval covers the code the reviewer saw. GitHub can dismiss stale approvals when new commits change the diff, and can require the most recent push to be approved by someone other than the person who pushed it. GitLab removes approvals by default when changes are added after them. If your setup keeps old approvals, re-request review after any push that changes behavior.
How to use LGTM effectively
Google's standard is to approve once a change "definitely improves the overall code health of the system being worked on, even if the CL isn't perfect." Approve once you know what the change does and you'd be fine supporting it.
Before you type it
You read every line you were assigned, or you said which parts you didn't review.
You know what the change is for (the PR description or ticket), and the code does that.
Tests cover the new behavior and CI passes. For migrations and UI changes, you ran it.
You checked what the change affects outside the diff: callers, config and data.
For AI-written code, the functions, packages and config keys it uses exist, error paths are handled, and it follows your team's conventions.
Someone qualified reviews the parts you can't judge, such as security or concurrency.
The code review checklist goes further, and how to review a pull request on GitHub covers the mechanics.
Approve with comments
Google's guide calls this LGTM with comments. You approve while leaving unresolved comments when you trust the author to address them, when the comments are optional, or when the fixes are minor, like sorting imports or fixing a typo. Say which case applies. Across time zones, it saves the author a day of waiting.
Label nits
Prefix minor comments with "Nit:" so the author can tell them from required changes. Google's comment guide defines a nit as "a minor thing. Technically you should do it, but it won't hugely impact things," and warns that without labels, authors may treat every comment as mandatory.
Say what you checked
A bare "LGTM" doesn't tell the author what you looked at. One more line does: "LGTM. Ran the migration locally and checked the rollback. Didn't review the CSS." An AI reviewer like cubic can take the first pass on every pull request, which leaves the human LGTM for design and intent (see how AI code review works).
Related acronyms
PTAL: please take a look. A request for review.
SGTM: sounds good to me. Agreement with a proposal, such as a design or a plan.
Nit: a minor comment you'd like fixed but won't hold the change for.
WIP: work in progress, not ready for review. On GitHub, use a draft pull request, which can't be merged until it's marked ready for review.
FAQ
What does LGTM mean?
LGTM means "looks good to me." In code review, it's how a reviewer approves a change, and in chat it's a quick OK. On platforms with formal approvals, the Approve action or vote is what counts, not the text.
Is it OK to say LGTM?
Yes. It's common shorthand in code review, and Google's own review guide uses it. Send it only after you've reviewed the change, and add a line about what you checked. With people outside tech, or in formal email, write the words out.
What is an example of LGTM?
On a pull request: "LGTM. Tests cover the new retry logic, one nit inline." In chat, someone writes "Updated the launch doc" and gets back "LGTM, send it."
What does LGTM mean in a chat?
It means the same thing: looks good to me. People use it to sign off on a draft, a plan or a proposed time without writing a full reply. It reads as agreement, so don't send it if you haven't looked.
