With Passive Aggressive Man

What With Passive Aggressive Man Actually Does

With Passive Aggressive Man is a browser extension that automates repetitive form-filling and web automation tasks through a visual scripting interface. You record a sequence of clicks and inputs, then replay them across different sessions. It targets people who find themselves doing the same tedious thing on the same websites every day, like filling out expense reports, uploading inventory files, or refreshing dashboards. The core idea is straightforward: stop doing it by hand. I've been running it for about two years across three different departments. The first month was a learning curve. The second month it started paying for itself. By month four I had about fourteen active scripts covering my entire workflow, and I'd stopped opening most of those sites manually.

With Passive Aggressive Man Installation and Setup

You can download the latest version from the official site at passiveaggressiveman.io/download. It supports Chrome, Firefox, and Edge. The installer adds the extension and creates a small desktop launcher, which is optional but saves you from opening the browser and navigating to the toolbar every time. After installation, open the extension dashboard. You'll see a blank workspace and a sidebar with your existing scripts, if any. The first thing you should do is connect it to your account by logging in through the prompted OAuth flow. Skipping this step means every script runs without authentication context, which breaks most workflows involving logged-in sites. I learned that the hard way. My first script was a disaster because I forgot this step, and it ran against a logged-out state for an hour before I caught it.

How the Scripting Works

Each script is a sequence of steps. A step can be click, fill, wait, scroll, extract, or condition. The visual editor lays these out as nodes connected by lines. You add nodes by clicking the + button, then select the action type and configure the parameters. Here is a practical example. Let's say you need to fill out a vendor onboarding form every Monday. The form has fields for company name, tax ID, contact email, and a dropdown for industry category. There are about twelve pages before the final submit button. Your script would look like this:

• Navigate to the vendor portal URL
• Wait for page load, verify the login banner is visible
• Fill company name field
• Fill tax ID field
• Select industry category from dropdown
• Click Next page button
• Repeat for remaining pages
• Click Submit
• Wait for success confirmation, extract the confirmation number

The entire setup takes roughly twenty minutes for a form of this complexity. After that, each run takes about eight seconds, compared to the fifteen minutes it would take by hand. The most common mistake is using a fixed wait instead of a conditional wait. A fixed wait pauses for a set number of milliseconds, like two seconds. A conditional wait keeps polling the page until an element appears or a condition is met, with a timeout fallback. Fixed waits are fragile. If the network slows down, the script fails. Conditional waits adapt. Always use conditional waits for page load detection and dynamic content. Set the timeout to something generous, like thirty seconds, so you get a clean failure message instead of a silent break halfway through.

One of my scripts that fills a government portal used a two-second wait after clicking Submit. The page sometimes rendered in four seconds, sometimes in nine. The script kept failing because the confirmation check ran before the page loaded. I switched to a conditional wait looking for the class .confirmation-banner, and the failure rate dropped to nearly zero.

Variables and Dynamic Data

Sometimes you need the same script to handle different data. Maybe you are processing fifty vendor records and each one needs its own values. That is where variables come in. You can pass variables when triggering a script. These appear in the editor as placeholders like {{company_name}} or {{tax_id}}. When you run the script through the API or the command line, you supply a JSON object with those keys. The extension substitutes the values at runtime. I built a single script that handles all vendor entries, then wrote a small Python script that reads from a CSV, generates the variable payloads, and triggers the automation in batches. The Python part runs in about ten minutes for fifty records. Doing it by hand would take over an hour and a half, with a high chance of typos.

Variable naming matters. Use underscores, not spaces. Spaces cause parsing errors that are hard to track down because the error message just says "invalid variable reference" without telling you which one.

Error Handling and Retries

Scripts fail. Sites change. Networks drop. You need a retry mechanism, and With Passive Aggressive Man has one built in. In the script settings, you can set maximum retries and what triggers a retry, like a failed step or a missing element. The default is one retry. That is not enough for anything that touches external systems. I set mine to three retries with an exponential backoff. The first wait is two seconds, the second is four, the third is eight. This handles transient errors without hammering the server. Another setting you should adjust is the step timeout. The default is ten seconds per step. If you are dealing with slow legacy portals, bump it to thirty or sixty. One portal I work with takes about forty seconds to respond to form submissions. The script would always time out at step seven before I changed this setting.

Logging and Debugging

When a script fails, the log shows which step failed, what the expected state was, and what the page actually looked like at that moment. This is usually enough to figure out the issue, but it can be noisy. I recommend turning on verbose logging during development and switching to normal once the script is stable. The console also captures network requests if you enable that option. I use it when a site is submitting data via AJAX instead of a regular form POST. You can see the actual request payload and verify it matches what you expect. Without this, you might spend twenty minutes wondering why the form submission appears to succeed but no data shows up in the backend. There is a snapshot feature too. It takes a screenshot of the page at each step. Useful for review, especially when sharing scripts with teammates or troubleshooting remotely.

Common Pitfalls

One pitfall is relying on CSS selectors that change frequently. Some sites update their class names on every deployment. If your script breaks after a site update, check whether the selector is still valid. I prefer using data-testid attributes or stable XPath expressions when available, because they tend to survive style changes better. Another pitfall is not accounting for two-factor authentication. If the site you are automating requires 2FA, the script will hang at the login step because it cannot provide the second factor. Workarounds exist, like using an authenticator API key or a hardware token emulator, but they require extra configuration and are not always supported. I hit this with a payroll system that added 2FA without warning. The script sat at the login screen for six minutes before the timeout kicked in. I had to reconfigure the login node to use a stored session cookie instead of credential input. That required a manual login first, exporting the session, and storing it securely in the variable manager.

Scheduling and Automation

You can trigger scripts on a schedule using the built-in scheduler or an external tool like cron or Task Scheduler. The scheduler runs scripts in the background even when the browser is minimized, but it does not work if the computer is asleep. If you are scheduling daily runs, make sure the machine stays on and connected. I had a script that ran every morning at 7 AM to pull inventory data. It worked fine for three weeks, then stopped. The office IT had a policy of shutting down machines at 6 PM, so the scheduler never fired. I moved the schedule to run through a remote VM that stays on overnight, and the problem disappeared.

Security Considerations

Scripts often handle sensitive data. Credentials, tax IDs, personal information. Store them encrypted in the variable manager, not in plain text. The extension supports environment-specific variable groups, so you can keep production and staging credentials separate. Audit your scripts regularly. Remove any that are no longer used. Unused scripts with stored credentials are a liability. I found three old scripts with expired passwords after a security review, and two of them had access to customer PII.

Performance and Limits

The extension can handle moderate workloads well. A single script with twenty steps typically completes in under ten seconds on a modern machine. Running multiple scripts in parallel is possible but limited by browser resource constraints. I usually cap it at five simultaneous scripts to avoid memory issues. If you need to process thousands of records, consider breaking the work into batches and using the API to trigger each batch. The API has a rate limit of about sixty requests per minute, which is enough for most bulk operations without hitting throttling.

Alternatives

If your needs are simpler, a basic macro recorder might be enough. If you need more advanced logic, custom integrations, or enterprise-grade governance, you might look at dedicated RPA platforms. With Passive Aggressive Man sits somewhere in between, which is why it works for teams that need more than a dumb macro but do not want the overhead of a full platform. I tried moving our team to a commercial RPA tool once. The licensing costs were steep, and the learning curve was steeper. I went back to With Passive Aggressive Man after six weeks. It does not have every feature the expensive tool has, but it does the job and the cost is reasonable.