The short version
An autonomous system probed Chipp's infrastructure. It rotated IP addresses, tested endpoints for server-side request forgery and tried to brute-force accounts. It adapted as we blocked it. It did not get in.
Chipp's autonomous development agents helped us expand logging, put exposed resources behind Cloudflare, turn on stronger bot challenges, shrink our attack surface and ship defensive changes while the attempt was still underway.
Recently, an autonomous system began probing Chipp’s infrastructure.
It rotated IP addresses. It tested endpoints. It attempted server-side request forgery. It tried to brute-force account access. It adapted as we blocked it.
It did not get in.
What stopped it was not a room full of engineers working through a traditional incident-response checklist. It was the autonomous development system already running inside Chipp. Our AI agents helped us expand logging, trace the traffic, move exposed resources behind Cloudflare, turn on stronger bot defenses, reduce our attack surface and deploy more protections while the attempt was still underway. Defensive changes could ship in 20 minutes or less.
We have spent years arguing that software development must become autonomous. This incident turned that argument into a live security exercise. The lesson was uncomfortable but clear:
When the attacker moves at the speed of AI, a defense that waits for humans cannot keep up.
Watch the debrief above, or read on for the written version.
This was not ordinary bot traffic
At first, we did not know whether we were seeing a real attack or an unusually aggressive crawler.
The traffic did not behave like a person manually testing a website. It came from rotating infrastructure, including a Python script that ran through GitHub Actions to change its source addresses. It kept changing its approach as defenses appeared.
Its behavior was consistent with an autonomous, AI-driven system. It was not repeating one request. It was probing for weaknesses across different surfaces. The attempts included:
- Testing endpoints for server-side request forgery
- Rotating source IP addresses
- Attempting brute-force access to accounts
- Looking for resources outside our protected edge
Our logs showed the activity. They did not show a successful intrusion. We saw no successful access to any account.
That distinction matters. This was an attempted attack, not a successful breach.
The security work started before the attack
The most important defenses were not created during the incident.
They were created every time our autonomous development system reviewed a change before shipping it. Our pipeline treats security as part of implementation, not as a final audit. It includes checks for cross-site request forgery (CSRF), server-side request forgery (SSRF) and security best practices. Those checks held back the first wave of the attempt and bought us time to react.
That work is easy to overlook when nothing goes wrong. During an attack, it becomes the time you have to act.
The bot-on-bot security incident
The response became a bot-on-bot contest. One autonomous system searched for a way in. Another changed the environment to keep it out.
Here is what our agents and our team did:
- Moved resources behind Cloudflare. We connected Cloudflare to our production infrastructure agent through MCP. The agent moved resources that had been running directly on Google Cloud behind Cloudflare’s edge.
- Challenged suspicious traffic. We turned on Cloudflare’s Super Bot Fight Mode to challenge suspicious requests.
- Increased observability. We expanded logging to see which paths were probed and how the behavior changed. We saw probing, and no successful access.
- Restricted access, then restored it in stages. We temporarily shut signups and logins. We brought them back gradually, with allowlists and added controls.
- Removed legacy infrastructure. Every running service gives an attacker another place to look. Instead of patching old systems in place, we took legacy infrastructure down to shrink the attack surface.
The result was a smaller attack surface and a simpler system to defend.
Why human review can become the dangerous step
“Never let AI deploy without a human reviewing it” sounds responsible. Sometimes it is. Sometimes it is the risk.
A human review queue adds latency. In normal development, that may mean a feature ships tomorrow instead of today. During an attack by an autonomous system, it means the attacker keeps probing while the defense waits for a person to be free.
That is the paradox. Requiring a person to approve every mechanical defensive step can make a system less safe, through delay, inconsistency and fatigue.
This is not an argument against human judgment. It is an argument for putting human judgment in the right place. People own intent, policy, architecture, permissions, escalation and accountability. Machines do the repeatable work of detecting, testing, patching, verifying and deploying inside the boundaries people set.
The unsafe version of autonomous development is an unconstrained model with production credentials and a vague instruction to “fix it.” The safe version is a system built on:
- Narrow permissions
- Isolated work
- Structured logs
- Explicit security checks
- Automated tests
- Deployment verification
- Rollback paths
- Clear escalation rules
Autonomy is not the absence of controls. It is the automation of controls.
Humans remained essential, but not in the hot path
People still made the most important decisions. Hunter recognized that the traffic was abnormal. He chose to prioritize containment over preserving legacy access. He decided when the evidence justified stronger action.
Those are judgment calls. But no person had to hand-write every rule, read every log line and run every deploy in sequence. The agents did the mechanical work at machine speed, which gave the humans more time for judgment.
This is the operating model we believe companies need:
AI for reaction speed. Humans for intent, policy and accountability.
The old security model cannot match autonomous attackers
Most security programs assume a human attacker and a human defender. An alert fires. Someone opens a ticket. An engineer investigates. A fix waits for review. A deployment window opens.
That sequence was already slow. Against an autonomous attacker, it gets slower still. An AI attacker can scan, test, adapt and try again while the first alert is still waiting for an owner.
That does not mean handing unrestricted production access to a chatbot. It means building an autonomous defense loop:
- Observe production continuously.
- Detect suspicious behavior and software weaknesses.
- Gather evidence without exposing secrets.
- Produce a narrowly scoped defensive change.
- Test that change against explicit security checks.
- Deploy it through controlled infrastructure.
- Verify the live result.
- Feed the outcome back into the system.
The loop has to be faster than the attacker’s loop.
Why going halfway on AI can be more dangerous
Many companies use AI at the edges: drafting text, summarizing documents, suggesting code. The core process stays human. That captures some productivity, but it does not create a new capability.
In an incident like this one, a tool that only suggests firewall rules or writes a patch and then waits in a review queue is slow. What helped us was the whole system:
- Agents could observe the real environment.
- They had the right infrastructure tools.
- They worked under defined permissions.
- They could make and verify changes.
- The deployment path was already autonomous.
- The process had already been exercised on ordinary production work.
You cannot build that response for the first time in the middle of an attack. Going all in on AI does not mean using it everywhere without thought. It means redesigning how the company works so AI can complete work safely, not just recommend it.
What this means for Chipp builders
A safe platform is not one that freezes after launch. Dependencies change, new vulnerabilities appear and attack techniques evolve. Software that was fine on launch day can become exposed later if nobody keeps it current.
Chipp runs projects on a managed, consistent stack, so we can build security work into the platform itself. That includes security checks during implementation, continuous production monitoring, automated investigation of new error signatures, and verified changes that go out through the same controlled deployment path as everything else. We are also building automated security migrations for our managed Deno and Svelte stacks, and automated security sweeps for known vulnerability classes.
This is the same principle behind our self-healing development system, which turns production problems into verified changes instead of waiting for a person to find and route each one.
No platform can honestly promise that attacks will never happen, and Chipp does not make that promise. Our commitment is to build the capacity to detect, respond, learn and improve at the speed modern threats require.
Security is becoming a living system
The old model treated security as a gate. You built software, passed a review and declared it secure. The new model treats security as a living system. It watches. It tests. It patches. It verifies. It remembers.
The same technology that gives attackers more speed can give defenders more speed, consistency and reach. The question is not whether a company uses AI. Attackers have already made that choice. The question is whether defenders will use AI deeply enough to keep up.
Our answer is yes, and we are building Chipp around it. To see how we build and maintain software this way, read Building a Self-Healing Bug Bot, or book a build session and start building on Chipp.


