diff --git a/tools/apilint/deprecated_at_birth.py b/tools/apilint/deprecated_at_birth.py
new file mode 100644
index 000000000000..297d9c3bcca0
--- /dev/null
+++ b/tools/apilint/deprecated_at_birth.py
@@ -0,0 +1,313 @@
+#!/usr/bin/env python
+
+# Copyright (C) 2021 The Android Open Source Project
+#
+# Licensed under the Apache License, Version 2.0 (the 'License');
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an 'AS IS' BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Usage: deprecated_at_birth.py path/to/next/ path/to/previous/
+Usage: deprecated_at_birth.py prebuilts/sdk/31/public/api/ prebuilts/sdk/30/public/api/
+"""
+
+import re, sys, os, collections, traceback, argparse
+
+
+BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(8)
+
+def format(fg=None, bg=None, bright=False, bold=False, dim=False, reset=False):
+    # manually derived from http://en.wikipedia.org/wiki/ANSI_escape_code#Codes
+    codes = []
+    if reset: codes.append("0")
+    else:
+        if not fg is None: codes.append("3%d" % (fg))
+        if not bg is None:
+            if not bright: codes.append("4%d" % (bg))
+            else: codes.append("10%d" % (bg))
+        if bold: codes.append("1")
+        elif dim: codes.append("2")
+        else: codes.append("22")
+    return "\033[%sm" % (";".join(codes))
+
+
+def ident(raw):
+    """Strips superficial signature changes, giving us a strong key that
+    can be used to identify members across API levels."""
+    raw = raw.replace(" deprecated ", " ")
+    raw = raw.replace(" synchronized ", " ")
+    raw = raw.replace(" final ", " ")
+    raw = re.sub("<.+?>", "", raw)
+    raw = re.sub("@[A-Za-z]+ ", "", raw)
+    raw = re.sub("@[A-Za-z]+\(.+?\) ", "", raw)
+    if " throws " in raw:
+        raw = raw[:raw.index(" throws ")]
+    return raw
+
+
+class Field():
+    def __init__(self, clazz, line, raw, blame):
+        self.clazz = clazz
+        self.line = line
+        self.raw = raw.strip(" {;")
+        self.blame = blame
+
+        raw = raw.split()
+        self.split = list(raw)
+
+        raw = [ r for r in raw if not r.startswith("@") ]
+        for r in ["method", "field", "public", "protected", "static", "final", "abstract", "default", "volatile", "transient"]:
+            while r in raw: raw.remove(r)
+
+        self.typ = raw[0]
+        self.name = raw[1].strip(";")
+        if len(raw) >= 4 and raw[2] == "=":
+            self.value = raw[3].strip(';"')
+        else:
+            self.value = None
+        self.ident = ident(self.raw)
+
+    def __hash__(self):
+        return hash(self.raw)
+
+    def __repr__(self):
+        return self.raw
+
+
+class Method():
+    def __init__(self, clazz, line, raw, blame):
+        self.clazz = clazz
+        self.line = line
+        self.raw = raw.strip(" {;")
+        self.blame = blame
+
+        # drop generics for now
+        raw = re.sub("<.+?>", "", raw)
+
+        raw = re.split("[\s(),;]+", raw)
+        for r in ["", ";"]:
+            while r in raw: raw.remove(r)
+        self.split = list(raw)
+
+        raw = [ r for r in raw if not r.startswith("@") ]
+        for r in ["method", "field", "public", "protected", "static", "final", "abstract", "default", "volatile", "transient"]:
+            while r in raw: raw.remove(r)
+
+        self.typ = raw[0]
+        self.name = raw[1]
+        self.args = []
+        self.throws = []
+        target = self.args
+        for r in raw[2:]:
+            if r == "throws": target = self.throws
+            else: target.append(r)
+        self.ident = ident(self.raw)
+
+    def __hash__(self):
+        return hash(self.raw)
+
+    def __repr__(self):
+        return self.raw
+
+
+class Class():
+    def __init__(self, pkg, line, raw, blame):
+        self.pkg = pkg
+        self.line = line
+        self.raw = raw.strip(" {;")
+        self.blame = blame
+        self.ctors = []
+        self.fields = []
+        self.methods = []
+
+        raw = raw.split()
+        self.split = list(raw)
+        if "class" in raw:
+            self.fullname = raw[raw.index("class")+1]
+        elif "enum" in raw:
+            self.fullname = raw[raw.index("enum")+1]
+        elif "interface" in raw:
+            self.fullname = raw[raw.index("interface")+1]
+        elif "@interface" in raw:
+            self.fullname = raw[raw.index("@interface")+1]
+        else:
+            raise ValueError("Funky class type %s" % (self.raw))
+
+        if "extends" in raw:
+            self.extends = raw[raw.index("extends")+1]
+            self.extends_path = self.extends.split(".")
+        else:
+            self.extends = None
+            self.extends_path = []
+
+        self.fullname = self.pkg.name + "." + self.fullname
+        self.fullname_path = self.fullname.split(".")
+
+        self.name = self.fullname[self.fullname.rindex(".")+1:]
+
+    def __hash__(self):
+        return hash((self.raw, tuple(self.ctors), tuple(self.fields), tuple(self.methods)))
+
+    def __repr__(self):
+        return self.raw
+
+
+class Package():
+    def __init__(self, line, raw, blame):
+        self.line = line
+        self.raw = raw.strip(" {;")
+        self.blame = blame
+
+        raw = raw.split()
+        self.name = raw[raw.index("package")+1]
+        self.name_path = self.name.split(".")
+
+    def __repr__(self):
+        return self.raw
+
+
+def _parse_stream(f, api={}):
+    line = 0
+    pkg = None
+    clazz = None
+    blame = None
+
+    re_blame = re.compile("^([a-z0-9]{7,}) \(<([^>]+)>.+?\) (.+?)$")
+    for raw in f:
+        line += 1
+        raw = raw.rstrip()
+        match = re_blame.match(raw)
+        if match is not None:
+            blame = match.groups()[0:2]
+            raw = match.groups()[2]
+        else:
+            blame = None
+
+        if raw.startswith("package"):
+            pkg = Package(line, raw, blame)
+        elif raw.startswith("  ") and raw.endswith("{"):
+            clazz = Class(pkg, line, raw, blame)
+            api[clazz.fullname] = clazz
+        elif raw.startswith("    ctor"):
+            clazz.ctors.append(Method(clazz, line, raw, blame))
+        elif raw.startswith("    method"):
+            clazz.methods.append(Method(clazz, line, raw, blame))
+        elif raw.startswith("    field"):
+            clazz.fields.append(Field(clazz, line, raw, blame))
+
+    return api
+
+
+def _parse_stream_path(path):
+    api = {}
+    print "Parsing", path
+    for f in os.listdir(path):
+        f = os.path.join(path, f)
+        if not os.path.isfile(f): continue
+        if not f.endswith(".txt"): continue
+        if f.endswith("removed.txt"): continue
+        print "\t", f
+        with open(f) as s:
+            api = _parse_stream(s, api)
+    print "Parsed", len(api), "APIs"
+    print
+    return api
+
+
+class Failure():
+    def __init__(self, sig, clazz, detail, error, rule, msg):
+        self.sig = sig
+        self.error = error
+        self.rule = rule
+        self.msg = msg
+
+        if error:
+            self.head = "Error %s" % (rule) if rule else "Error"
+            dump = "%s%s:%s %s" % (format(fg=RED, bg=BLACK, bold=True), self.head, format(reset=True), msg)
+        else:
+            self.head = "Warning %s" % (rule) if rule else "Warning"
+            dump = "%s%s:%s %s" % (format(fg=YELLOW, bg=BLACK, bold=True), self.head, format(reset=True), msg)
+
+        self.line = clazz.line
+        blame = clazz.blame
+        if detail is not None:
+            dump += "\n    in " + repr(detail)
+            self.line = detail.line
+            blame = detail.blame
+        dump += "\n    in " + repr(clazz)
+        dump += "\n    in " + repr(clazz.pkg)
+        dump += "\n    at line " + repr(self.line)
+        if blame is not None:
+            dump += "\n    last modified by %s in %s" % (blame[1], blame[0])
+
+        self.dump = dump
+
+    def __repr__(self):
+        return self.dump
+
+
+failures = {}
+
+def _fail(clazz, detail, error, rule, msg):
+    """Records an API failure to be processed later."""
+    global failures
+
+    sig = "%s-%s-%s" % (clazz.fullname, repr(detail), msg)
+    sig = sig.replace(" deprecated ", " ")
+
+    failures[sig] = Failure(sig, clazz, detail, error, rule, msg)
+
+
+def warn(clazz, detail, rule, msg):
+    _fail(clazz, detail, False, rule, msg)
+
+def error(clazz, detail, rule, msg):
+    _fail(clazz, detail, True, rule, msg)
+
+
+if __name__ == "__main__":
+    next_path = sys.argv[1]
+    prev_path = sys.argv[2]
+
+    next_api = _parse_stream_path(next_path)
+    prev_api = _parse_stream_path(prev_path)
+
+    # Remove all existing things so we're left with new
+    for prev_clazz in prev_api.values():
+        if prev_clazz.fullname not in next_api: continue
+        cur_clazz = next_api[prev_clazz.fullname]
+
+        sigs = { i.ident: i for i in prev_clazz.ctors }
+        cur_clazz.ctors = [ i for i in cur_clazz.ctors if i.ident not in sigs ]
+        sigs = { i.ident: i for i in prev_clazz.methods }
+        cur_clazz.methods = [ i for i in cur_clazz.methods if i.ident not in sigs ]
+        sigs = { i.ident: i for i in prev_clazz.fields }
+        cur_clazz.fields = [ i for i in cur_clazz.fields if i.ident not in sigs ]
+
+        # Forget about class entirely when nothing new
+        if len(cur_clazz.ctors) == 0 and len(cur_clazz.methods) == 0 and len(cur_clazz.fields) == 0:
+            del next_api[prev_clazz.fullname]
+
+    for clazz in next_api.values():
+        if "@Deprecated " in clazz.raw and not clazz.fullname in prev_api:
+            error(clazz, None, None, "Found API deprecation at birth")
+
+        if "@Deprecated " in clazz.raw: continue
+
+        for i in clazz.ctors + clazz.methods + clazz.fields:
+            if "@Deprecated " in i.raw:
+                error(clazz, i, None, "Found API deprecation at birth " + i.ident)
+
+    print "%s Deprecated at birth %s\n" % ((format(fg=WHITE, bg=BLUE, bold=True),
+                                            format(reset=True)))
+    for f in sorted(failures):
+        print failures[f]
+        print