My first attempt at programmatically drafting a modern wordcloud analysis on this site was a valuable exercise in pairing AI agents with real-world deployments. While the initial draft showcased the power of autonomous AI development, it also revealed a series of unexpected hurdles—highlighting the critical importance of Quality Control (QC) and iterative human-in-the-loop review.

The Deployment Hiccups

Deploying code in isolation is easy, but placing it into a live environment with firewalls and active configurations rarely goes perfectly on the first try. Here is what we ran into:

1. Firewall (WAF) Interception: When attempting to save the post HTML containing the Python script via Gutenberg’s REST API, the server’s LiteSpeed Web Application Firewall (WAF) threw a 403 Forbidden error. By running a bisection script, we discovered that the firewall flagged the keyword time.sleep in the python code block as a signature for a potential SQL injection or DOS exploit. Removing this single line allowed the content to save natively.
2. Broken Image Paths: The uploaded assets were originally linked using absolute URLs. Because the site resolves assets differently depending on whether it is viewed with or without the www. prefix, the browser blocked the image rendering. Switching to root-relative paths (e.g. starting with /wp/wp-content/uploads/...) resolved the rendering across all domain configurations.

The Stale Data Problem: Blindly Trusting Feeds

Perhaps the most significant lesson came from the generated CNN wordcloud itself. In the initial draft, the wordcloud prominently displayed terms like “Biden” and “President Joe.” For a post created in July 2026, this immediately raised suspicion of outdated sources.

Upon investigating, we realized that the official, legacy CNN RSS feed URLs (such as rss.cnn.com/rss/cnn_topstories.rss) are no longer actively maintained. Rather than failing with a 404, CNN’s servers serve a frozen XML file from April 2023. The AI agent, when instructed to fetch the feed, parsed it successfully and generated a wordcloud based on news from three years ago, completely unaware that the data was stale.

QC and Iterative Refinement

This discrepancy underscores why AI-generated outputs must undergo quality control. Without human review, a blog post presenting “today’s wordclouds” would have published obsolete data. To correct this, we iterated on the process:

1. Live Feed Correction: We updated the CNN data source to fetch live news search feeds from Google News (targeting site:cnn.com), which indexes real-time articles from today (July 2026).
2. Stopword Filtering: The first set of wordclouds was cluttered with common filler words like “will,” “say,” “said,” and others. We implemented a much more restrictive stopwords dictionary to filter out these auxiliaries, leaving only the key thematic news terms.

The Refined Wordclouds (Today)

Here are the corrected, live wordclouds generated using the updated crawler and restrictive filtering:

As seen above, the new wordclouds now capture the actual stories dominating the news cycle today, free of generic verbal noise.

Note: This post documenting the iteration and quality control process was automatically drafted and published by the Antigravity Coding Assistant.

Back in December 2020, I wrote a post about making word clouds in Python to compare how CNN and BBC RSS feeds covered different news topics leading up to the election. Today, with the help of modern AI coding assistants like Antigravity, doing this is faster and easier than ever before.

How easy is it today?

To demonstrate, here is a screenshot of the prompt I gave to Antigravity (with credentials securely blacked out and unrecoverable):

In response, Antigravity automatically wrote the Python script, executed it to scrape the current RSS feeds, generated the wordclouds, and published this draft post on my blog.

What do the Wordclouds look like today?

Here are the generated wordclouds from today’s CNN and BBC RSS feeds (July 25, 2026):

The Underlying Python Code

This is the modern and clean Python code used by Antigravity to scrape the feeds and generate the wordclouds above:

# Generated by Antigravity Coding Assistant

import requests
from bs4 import BeautifulSoup
from wordcloud import WordCloud, STOPWORDS
import matplotlib.pyplot as plt
import urllib3

urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)

# RSS feed lists
cnn_urls = [
    "http://rss.cnn.com/rss/cnn_topstories.rss",
    "http://rss.cnn.com/rss/cnn_world.rss",
    "http://rss.cnn.com/rss/cnn_us.rss",
    "http://rss.cnn.com/rss/cnn_allpolitics.rss",
    "http://rss.cnn.com/rss/cnn_tech.rss",
]

bbc_urls = [
    "http://feeds.bbci.co.uk/news/rss.xml",
    "http://feeds.bbci.co.uk/news/world/rss.xml",
    "http://feeds.bbci.co.uk/news/uk/rss.xml",
    "http://feeds.bbci.co.uk/news/business/rss.xml",
    "http://feeds.bbci.co.uk/news/politics/rss.xml",
    "http://feeds.bbci.co.uk/news/technology/rss.xml",
]

def generate_wc(urls, output_filename, colormap):
    text_data = []
    for url in urls:
        try:
            resp = requests.get(url, verify=False, timeout=10)
            if resp.status_code == 200:
                soup = BeautifulSoup(resp.content, features="xml")
                items = soup.findAll('item')
                for item in items:
                    title = item.title.text if item.title else ""
                    desc = item.description.text if item.description else ""
                    text_data.append(title)
                    text_data.append(desc)
        except Exception as e:
            print(f"Error fetching {url}: {e}")
        
    full_text = " ".join(text_data).replace(""", "").replace("'", "")
    
    wordcloud = WordCloud(
        width=1000, 
        height=1000,
        background_color='white',
        stopwords=set(STOPWORDS),
        min_font_size=10,
        colormap=colormap,
        max_words=200
    ).generate(full_text)
    
    plt.figure(figsize=(10, 10), facecolor=None)
    plt.imshow(wordcloud)
    plt.axis("off")
    plt.tight_layout(pad=0)
    plt.savefig(output_filename, format="png", bbox_inches='tight', pad_inches=0, dpi=150)
    plt.close()

# Generate the wordclouds
generate_wc(cnn_urls, "cnn_wordcloud.png", "viridis")
generate_wc(bbc_urls, "bbc_wordcloud.png", "inferno")

Note: This post, including all code generation, asset visualization, and content drafting, was automatically generated and posted by the Antigravity Coding Assistant.

I recently completed a two year visit at the Securities and Exchange Commission (SEC). While at the Commission, I worked at the Office of Litigation Economics, which is, in turn, housed in the Division of Economic and Risk Analysis (known as DERA, which houses most of the economists in the SEC).

I worked on a number of enforcement cases, typically helping enforcement attorneys with the economic aspects of various cases. A press release on the types of cases SEC Enforcement brought in 2024 can be found in this press release. Additionally, I helped review papers for the Conference on Financial Markets and Regulation (CFMR), an annual academic conference held at the SEC, and co-sponsored by several Universities.

Overall, it was a wonderful experience, and I learnt a lot. From feedback I received from colleagues and supervisors at the Commission, I also gathered that the insights I brought from academia were valued as we helped Enforcement attorneys with their cases.

I am back full-time at the University of Alabama now and will continue my missions of teaching, research and service. I’m sure insights from my time at the Commission will also be useful in these missions.

One of the ways I motivate using Python (over Excel) for analysis in my quantitative investing class is through simulations. Any time it is difficult to find a closed form solution, simulation is useful. Nonlinearities, such as those in hedge fund compensation contracts, are an ideal example. Is a 2/20 (referring to 2% management fee, 20% incentive fee) contract “better” than a 1.5/30 contract? Or is a 2/20 with high water mark (HWM) better than a 1.5/15 without a HWM? These questions cannot be easily answered with closed form solutions, especially if we consider some dynamics in terms of investor withdrawal, or in the fund manager’s choice of investment technology. The only way to reasonably tackle these is to simulate a bunch of outcomes and see what happens in those outcomes, to generate expected returns for the investor.

This is an ideal use case for Python, with nested “for” loops over simulation runs, and multiple time periods, with optimization by both investors and fund managers coded in. In fact, one of the (sadly unpublished) papers from my dissertation was about this. In that paper I used MATLAB for the coding, but the logic would be very similar for Python.

However, a lot of my students are not familiar with coding and as an alternative, I cover a way to use Excel to do similar analysis. The key is an off book use of the Data Table function. Data Tables are generally used for sensitivity analysis – seeing how output cells change with different input cell values.

Data tables can also be used to run simulations in Excel – for example, below is a spreadsheet that computes to the evolution of a hedge fund that starts with $100, uses a normal return technology with mean annual returns of 8% and std dev of 20%, and charged 1.5% management fee and 20% incentive fee. In the base run, this 100 dollars evolves to 120.07 at the end of 5 years. The formulae for the various computed cells are shown as well.

In columns N and O, we have a data table, with the first column being the run number – we are doing 10,000 runs, so while the screen shot only shows runs 1-22, there are 9,978 rows below. Unlike traditional sensitivity analysis data tables, here, we simply have the table set to input the values in column N (the sim run column) into an empty cell (for example $F$19)

So, Excel will put 1 in F19, then record the Post Fee AUM value at the of 5 years in cell O4, then it will put 2 in F19, which will re-run all the random numbers, and put the new 5 year post fee AUM number in cell O5, and so on. At the end of this, we will get 10,000 different values of the AUM at the end of 5 years, and we can use those values to get the expected return of the fund (cell Q4). We can also get other moments, or generate VaR and CVaR type measures with these data.

It’s clunky, but it gets the job done.

I recently started looking into some natural language processing (NLP) techniques, largely as a consumer of such research, rather than as a producer of such research. With the large amount of textual data available (10-K MD&A sections, Mutual Fund form N-CSR’s management discussion sections, analyst reports, news articles, earnings calls, etc. etc.) this seems to be fertile ground for new research.

My sense is the earlier work in this area largely revolved around word counts and treating text as a “bag of words” and then counting how many times certain types of words appeared in these bags. For example, for sentiment analysis, a common technique would be to count the number of positive words (where positive words were given by some dictionary, e.g. this one) and then counting the number of negative words and then taking a ratio of positive to negative words to determine the overall sentiment of a piece of text. Some work extended this by created custom dictionaries to address the unique vocabulary in finance and accounting.

Newer work seems more tech-ed up and generally considers the relationship between words (for example the word “board” in “being on board” and “board of directors” means very different things). This type of work uses constructs that are harder to parse through dictionaries, and generally uses some type of machine learning to link blocks of text with a measurable variable. For example, a researcher might train a computer by providing a few thousand sentences, along with the researcher’s classification of these sentences into positive, negative, and neutral sentences. After this, the computer can generally classify sentences quite accurately out-of sample.

I toyed around with the simplest version of this (bag of words, positive vs negative counts, etc.) and wrote some code that takes a news article and gives number of positive words, negative words, and total words. The code is below.

# these are imports not all are needed 
import pandas as pd
import urllib.request
import html2text
import requests
from string import punctuation
from googlefinance import getQuotes
import json
from yahoo_finance import Share
import time
import datetime
import ast

# This bit gets positive and negative words from your dictionaries
pos_sent = open("positive.txt").read()
positive_words=pos_sent.split('\n')
neg_sent = open("negative.txt").read()
negative_words=neg_sent.split('\n')

#this defines a function that takes a block of text as input, along with 3 number variables and returns 3 number variables with 
def parsenews(response,positive_counter,negative_counter,total_words):
    # this next bit formats the response txt as needed -
    txt = response.text
    simpletxt = html2text.html2text(txt)
    #print(simpletxt)
    #print(txt)      
    simpletxt_processed=simpletxt.lower() 
    # this removes punctuation
    for p in list(punctuation):
        simpletxt_processed=simpletxt_processed.replace(p,'')
        words=simpletxt_processed.split(' ')
    for word in words:
        if word in positive_words and len(word) > 2:
            #print(word)
            positive_counter=positive_counter+1
        if word in negative_words and len(word) > 2:
            #print(word)
            negative_counter=negative_counter+1
    total_words = total_words + len(words)
    return positive_counter,negative_counter,total_words

It seemed relatively straightforward to do the “bag of words” positive vs negative sentiment counts. At some point, I might try the more complicated stuff, but for now, I just look forward to seeing more cool studies using these techniques.