dellamora/webscraper-to-identify-which-girls-and-how-many-of-them-my-boyfriend-follows-on-github

This repository appears to be a very small, single-purpose Python tool rather than a multi-service application. The whole system is likely centered in muhahaha.py, with requirements.txt providing the runtime dependencies and README.md documenting the behavior.

The main entry point is probably a single script that drives the full workflow end to end: connect to GitHub, inspect a target user’s following list, classify usernames, and print a percentage result. There is no evidence of separate packages, background workers, databases, or web servers.

A useful way to diagram it is as three internal stages inside one script. First is GitHub data collection: the tool “stalks” a GitHub following page, so it likely fetches or scrapes the list of accounts a target user follows. Second is AI-based classification: the README says it uses Claude to identify “feminine usernames,” so the script probably sends candidate names to Anthropic’s Claude API and receives a label or score. Third is aggregation/reporting: it computes the percentage of followed accounts that match the feminine classification and returns that to the user.

The boundary between GitHub and the local program is important. The script likely acts as a client consuming GitHub profile/following data, either through HTTP scraping or browser-like requests. That means the GitHub side is an external data source, not a local subsystem.

The boundary between the script and Claude is also important. Claude is the only clearly implied external AI service. The classification step is not happening locally; the script depends on an API call out to Anthropic, then uses the model’s output as a decision input.

The README’s note about “pretends to be a normal browser” suggests the script may include request headers, session handling, or other anti-bot evasion behavior. Architecturally, that means the data collection layer is probably not a simple API call; it is likely wrapped in a browser-emulation or stealth HTTP client layer.

The output path looks simple: after collection and classification, the script computes a ratio and reports a percentage. There is no sign of persistence, dashboards, or downstream integrations. The program likely exits after printing the result.

Operationally, the whole repo depends on two external systems only: GitHub for source data and Claude for classification. That makes the architecture a thin orchestration layer around external services, with very little internal state.

For an architecture diagram, the cleanest representation is: user launches muhahaha.py → script fetches a GitHub following page → script sends usernames or profile identifiers to Claude → script aggregates model judgments → script returns a percentage to the user.

Because the repository contains only one Python file plus dependency metadata, the architecture is intentionally minimal. Most of the “system” is in how that script coordinates I/O, rather than in multiple internal modules or service boundaries.