Amplitude liefert mit Cursor 3x mehr produktionsreifen Code
Amplitude nutzt Cursor, um eine autonome Entwicklungspipeline aufzubauen, die Software mit minimalem Eingreifen von Entwicklern von der Idee bis in die Produktion bringt.
Das Engineering-Team von Amplitude wollte eine vollständig autonome Entwicklungspipeline aufbauen, die Software mit minimalem Eingreifen von Entwicklern von der Idee bis in die Produktion bringen kann. Mit Cursor hat Amplitude jetzt Systeme eingerichtet, die Kontext aus dem gesamten Softwarelebenszyklus aufnehmen–von Kundenfeedback über Observability-Tools bis hin zu Code-Reviews–und ihn zur Ausführung an Agenten übergeben.
Wenn Kund:innen jetzt Bugs oder Feature-Requests in Slack melden, werden Cloud-Agenten automatisch gestartet, um den Fall zu untersuchen, ein Ticket zu erstellen und einen Fix zu schreiben. Cursor-Automatisierungen laufen kontinuierlich im Hintergrund, migrieren Legacy-Code und klassifizieren die Risikostufen für jede neue oder aktualisierte PR. Bugbot dient als erste Instanz im Review-Prozess, mergt Änderungen mit geringem Risiko automatisch und leitet PRs mit hohem Risiko an die richtigen Reviewer weiter.
Die meisten KI-Coding-Tools liefern dir mehr Code. Cursor liefert dir mehr nützliche produktionsreife Software. Der Unterschied ist die Fähigkeit, Agenten auszuführen, die Arbeit effektiv parallelisieren, ihre eigenen Änderungen testen und ein Feature von der Idee bis in die Produktion bringen können.
Rein lokal ausgeführte Agenten begrenzen Parallelisierung und Autonomie
Schon früh bei der Einführung von Agenten stieß Amplitude auf das, was Adam Lohner, Staff Software Engineer, als ein trügerisches Plateau der Entwicklungsproduktivität beschrieb.
Echte Beschleuniger für das Entwicklungstempo entstehen, wenn Agenten tatsächlich nützliche produktionsreife Software liefern — nicht einfach nur viel Code. Dafür brauchten wir deutlich mehr Parallelisierung und Autonomie bei Agenten, und genau das können Agenten nicht bieten, wenn sie auf lokale Entwickler-Workstations beschränkt sind.
Lokale Agenten konkurrieren um dieselben begrenzten Ressourcen und geraten schnell in Konflikte. Schon wenn zwei oder drei Agenten gleichzeitig ausgeführt werden, kann die Leistung spürbar nachlassen. Die Codebasis von Amplitude ist groß genug, dass lokale Entwicklerrechner an ihre Speichergrenzen stießen — selbst auf High-End-Hardware mit viel RAM.
Lokale Agenten haben außerdem keinen Zugriff auf eine vollständige Entwicklungsumgebung, wie sie einem Engineer zur Verfügung steht. Ohne sie können Agenten ihre eigene Arbeit nicht testen oder verifizieren. Entwickler müssen Umgebungen weiterhin konfigurieren, End-to-End-Tests ausführen und Änderungen manuell verifizieren, bevor überhaupt etwas ausgeliefert werden kann.
Die Cloud sprengt die lokalen Grenzen für Agenten
Für mehr Parallelisierung und Autonomie setzt Amplitude auf Cursors Cloud-Agenten. Besonders herausgestochen haben dabei einige Funktionen:
- Parallele Ausführung in großem Maßstab: Cloud-Agenten laufen in isolierten, skalierbaren VMs und heben damit die Ressourcenlimits auf, die lokale Parallelisierung ausbremsen.
- Vollständige Entwicklungsumgebung: Cloud-Agenten können ihre Arbeit testen, verifizieren und iterieren – genau wie ein Ingenieur – und haben dabei Zugriff auf eine vollständige Entwicklungsumgebung.
- Lang andauernde Ausführung: Amplitude übergibt Cloud-Agenten tiefere, ambitioniertere Aufgaben, die sie Ende zu Ende bearbeiten, statt nur kurze, synchrone Jobs.
- Immer aktive Agenten: Mit Cursor Automatisierung kann Amplitude Cloud-Agenten einrichten, die auf Trigger oder nach wiederkehrenden Zeitplänen laufen, statt manuell per Prompt gestartet zu werden.
Wir lassen viele Cloud-Agenten gleichzeitig in Cursor laufen, jeder mit vollständigem Zugriff auf unseren Tool-Stack. Die Möglichkeit, Agenten hochzufahren, die nicht an lokale Ressourcenlimits stoßen und kein ständiges Mikromanagement brauchen, war ein echter Quantensprung.
Die Ingenieure bei Amplitude wechseln heute je nach Art der Arbeit zwischen Cloud- und lokalen Agenten. Neue Ideen starten oft in der Cloud, wo Cursors Laufzeitumgebung Agenten erlaubt, über längere Zeit selbstständig zu arbeiten. Viele Ingenieure starten Cursor direkt aus Slack-Threads, in denen Feature-Ideen diskutiert werden.
Entwickler holen Agenten in die lokale Umgebung, wenn sie sich auf stärker kontrollierte Iterationen konzentrieren oder tiefer in die Details einsteigen wollen. Cursor dient dabei als einheitlicher Workspace über Cloud und lokal hinweg.
Cursor bietet die beste Oberfläche, um all deine verschiedenen parallelen Agenten zu orchestrieren. Du kannst auf einer hohen Ebene bleiben oder bei Bedarf in Details wie Diffs und Dateien eintauchen.
Seit der Einführung von Cloud-Agenten hat Amplitude seine wöchentlichen Commits in die Produktion verdreifacht. Gemessen am Commit-Volumen ist Cursor inzwischen einer der drei größten Beitragenden zu Amplitudes Codebasis – mit über 1.000 Agent-Läufen pro Woche, die ganz ohne Prompts oder Eingreifen von Entwicklern gestartet werden.
In der Cloud wird Software entwickelt, lokal testen und iterieren wir. Cursors Unterstützung für nahtlose Übergaben zwischen beidem war der entscheidende Hebel für Amplitudes Produktgeschwindigkeit.
Von Slack zum Ticket zur PR
Amplitude hat eigene Slack-Kanäle, in denen Field-Teams Bug-Meldungen und Feature-Requests von Kunden weiterleiten. Vor Cursor gab es dafür ein eigenes Teammitglied, das diese Kanäle überwachte, Issues triagierte, Tickets nachverfolgte und Arbeit aus dem Backlog zuwies.
Dann entwickelte Pauly eine Cursor-Automatisierung, um diesen gesamten Arbeitsablauf an Agenten zu übergeben. Wenn eine neue Nachricht in Slack eingeht, prüft ein Cloud-Agent in Linear, ob für das Problem bereits ein Ticket existiert. Falls ja, fügt der Agent den neuen Kundenkontext hinzu. Falls nicht, untersucht der Agent die Codebasis, eröffnet ein neues Ticket und eröffnet eine PR mit der implementierten Lösung.
Cursor-Automatisierungen helfen uns, die Lücke zwischen unseren Kunden und unseren Ingenieuren zu schließen. So können wir schneller auf Kundenanforderungen reagieren und bessere Lösungen liefern.
Mit dieser Vorlage kannst du eine Automatisierung erstellen, die Slack-Meldungen in PRs umwandelt.
Automatisiertes Legacy-Refactoring
In Amplitudes Frontend-Codebasis hatten sich über Jahre hinweg konkurrierende Muster angesammelt – darunter Legacy-CSS-Komponenten, veraltete React-Layouts und inkonsistente Styling-Konventionen.
Wir haben so viele konkurrierende Legacy-Muster, dass Agenten kaum erkennen können, wie es richtig weitergeht. Das ist ein klassisches Garbage-in-garbage-out-Problem.
Um das zu beheben, entwickelte Lohner eine Reihe cronbasierter Cursor-Automatisierungen, die stündlich laufen, um Legacy-Migrationen nach und nach voranzutreiben. Eine Automatisierung durchsucht CSS-Dateien nach Styles, die sich direkt durch Tailwind-Klassen ersetzen lassen, nimmt die Ersetzungen vor, löscht die alten Dateien, öffnet eine PR und sendet eine Slack-Benachrichtigung. Eine weitere ersetzt Amplitudes mehr als 20.000 Legacy-React-Layout-Komponenten durch native Tailwind-Alternativen.
Diese Migrationen als Automatisierungen in der Cloud auszuführen bedeutet, dass sie kontinuierlich im Hintergrund laufen, ohne andere Arbeit zu verdrängen oder Entwicklerzeit zu beanspruchen.
Agentengesteuerte Code-Reviews
Der andere Engpass, der Amplitudes Entwicklungsgeschwindigkeit bremste, waren manuelle Code-Reviews. Amplitude wollte einen Review-Prozess, bei dem Agenten im Mittelpunkt stehen, der die Zuverlässigkeit des Produkts verbessert und zu weniger Unterbrechungen für Entwickler führt.
Amplitude implementierte Bugbot als dedizierte Ebene für agentenbasierte Reviews. Die Nutzung nahm organisch zu, als Entwickler sahen, dass Bugbot Probleme erkannte, die menschlichen Reviewern angesichts der Größe und Komplexität von Amplitudes Codebasis entgingen.
Bugbot entdeckt regelmäßig wirklich knifflige Bugs und schlägt dafür solide Lösungen vor.
Lohner erstellte außerdem eine Cursor-Automatisierung, die das Risiko und die Auswirkungen jeder PR bewertet. Änderungen mit geringem Risiko können für den Merge freigegeben werden, wobei Bugbot Probleme ohne Eingreifen von Entwicklern prüft und automatisch behebt. PRs mit hohem Risiko und komplexeren Logikänderungen werden automatisch an die richtigen Ingenieure weitergeleitet. Etwa 60-70 % der PRs mit geringem Risiko werden ohne zusätzlichen Aufwand für Entwickler gemergt. Mit dieser Vorlage können Sie eine Automatisierung erstellen, die Slack-Berichte in PRs umwandelt.
Bugbots Erfolgsbilanz beim regelmäßigen Aufspüren echter, produktionskritischer Bugs hat es zu einem zentralen Bestandteil unseres Code-Review-Prozesses gemacht.
Als Nächstes konzentriert sich Amplitude darauf, Automatisierungen auf die zweite Hälfte des Entwicklungslebenszyklus auszuweiten: CI/CD-Pipelines, Build-Validierung und Deployment. Das Ziel ist, dass Agenten Software ohne Eingreifen von Entwicklern von der geprüften PR bis in die Produktion bringen.
Wenn Sie daran interessiert sind, mit Cursor autonome Entwicklungspipelines zu erstellen, kontaktieren Sie bitte unser Team, um eine Cursor-Testversion zu starten.
