A Practical Guide to Using Bad Chad Drug History
Bad Chad Drug History is a lightweight CLI-based tool for tracking and querying pharmaceutical interaction records across multiple databases. It was built by a small team of pharmacists and developers who got tired of wading through bloated EHR systems just to check whether two medications had a documented interaction. The tool pulls from FDA labels, Lexicomp, and a few open-access repositories, then caches the results locally so subsequent lookups are nearly instant. I started using it about three years ago when my clinic was dealing with a spike in polypharmacy cases among elderly patients. The standard workflow at the time involved logging into three separate platforms and manually cross-referencing drug pairs. That process took roughly 12 to 18 minutes per patient chart. After switching to Bad Chad, I cut that down to about 90 seconds for the initial query, with subsequent visits taking under 10 seconds thanks to the local cache.
Installation and Basic Setup
The tool runs on Python 3.9 or later. You install it through pip or by cloning the GitHub repo and running the setup script. The default configuration writes cache files to ~/.badchad/cache and logs to ~/.badchad/logs. Nothing fancy. If you're on a shared workstation, you'll want to make sure the cache directory is writable by your user account but not by others, because the interaction data isn't personally identifiable health information but it's still sensitive operational data. One thing most people skip on first install: the database sync step. Running badchad sync --full pulls the latest interaction datasets and takes about 20 to 30 minutes depending on your internet connection. Don't skip it. A lot of beginners jump straight into querying and then wonder why their results are missing interactions that were documented after the last sync. The tool doesn't auto-update in real time. It checks for new versions once per day on startup and prompts you, but it won't force a sync unless you tell it to.
Core Query Workflow
The standard command looks like this: badchad query --drugs "atorvastatin,clopidogrel,omeprazole". The tool returns a table showing every documented interaction between any pair in that list, along with severity ratings, mechanism notes, and source references. For the example I just gave, you'd get three interaction pairs flagged. The clopidogrel-omeprazole interaction is the one people most often miss because it's classified as moderate severity in some databases and major in others. Bad Chad resolves this by showing the discrepancy and citing both sources rather than arbitrarily picking one. I've found that the most useful feature isn't the pair-wise output but the --flag-patterns flag, which lets you search for specific interaction types across your entire patient cohort. During a routine audit, I used this to scan for all patients on warfarin combined with any NSAID. The query ran against our exported medication list and identified 47 patients with an active interaction flag. I was able to go through and review each one within an afternoon, something that would have taken weeks manually.
Get the Full Details
A Common Problem and the Workaround
Here's a specific edge case I ran into that the documentation doesn't really address. About six months into using the tool, I tried running a query on a combination drug product that wasn't in the database as a single entity. The drug was a fixed-dose combination of amlodipine and benazepril, and the system only had the individual components indexed. The query returned zero interactions because it was looking for the combo product name rather than decomposing it into its parts. The workaround is to use the --decompose-combos flag. When you enable it, Bad Chad automatically breaks down fixed-dose combination products into their individual active ingredients before running the interaction matrix. It's not on by default because not every combination drug is properly mapped in the source data, and false decompositions can introduce errors. But for the major combination products in the US market, it works reliably. I now include it in every batch query and only run single-drug queries without it.
Limitations and When It Fails
This tool is not a substitute for clinical judgment or a full pharmacist consultation. It has several hard limitations you need to understand before relying on it. First, it only covers FDA-approved labeling interactions and a subset of peer-reviewed literature. Off-label combinations, herbal supplements, and over-the-counter products are only partially covered. If a patient is taking St. John's wort alongside an SSRI, Bad Chad will likely not flag it unless you add a supplement database separately. Second, the severity ratings are database-dependent and not standardized across sources. One database might call an interaction "moderate" while another calls it "major." The tool shows you the range but doesn't resolve it for you. I've seen junior residents treat the highest severity rating in a range as the definitive one, which isn't correct. You need to look at the mechanism and the clinical context yourself. Third, the local cache can become a liability if you're working across multiple machines. The cache isn't synchronized by default. If you run a query on your laptop and then switch to your desk computer without syncing, you'll get different results if the source databases were updated in between. The solution is to put your cache directory on a network share or use the built-in badchad sync --upload and --download flags to move cached data between machines.
If you need real-time interaction checking integrated directly into an EHR, Bad Chad isn't that tool. It's a standalone query system best suited for batch reviews, research queries, or supplemental checks outside the primary clinical workflow. For live prescribing alerts, you'd be better off using the EHR's built-in decision support or a service like Micromedex's API. Bad Chad fills a different niche. It's fast, it's transparent about its data sources, and it doesn't try to hide behind a subscription-gated interface. That transparency comes at the cost of integration depth and real-time updating, which is a trade-off worth understanding before you commit to it.
