AI Jargon, Demystified: Understanding Key Concepts for Effective AI Use

This article aims to demystify three often misunderstood concepts in AI: tokenizable data, jagged intelligence, and when to apply big prompts versus casual chats. Understanding these ideas is fundamental to effectively using and augmenting AI.

1. What is Tokenizable Data?

Tokenizable data is anything that could appear in a document, like Word files or a wiki. AI reads text in tokens (chunks of about four characters), so the easier your data turns into text, the more AI can do with it. Spreadsheets are harder, and giant data lakes need a search step first.

Defining Tokenizable Data:
- A piece of data is likely tokenizable if it could appear in a document.
- This concept is the starting point for determining if AI can process something. Before asking if AI can do a task, first ask if the data can even fit or if the tokens will go into the system.
- A token is a small chunk, like a piece of a word, typically about four characters, that passes into the transformer.
Tiers of Tokenizable Data:
- Tier A: Easily Tokenized Data
  - Examples include Word documents and anything in a wiki.
  - Such data allows you to more easily shape your destiny with AI and content. For instance, company policies in a few neat Word documents can easily be fed into LLMs, giving immediate control and allowing you to “be off to the races”.
- Tier B: Spreadsheet Scale Data
  - Spreadsheets don’t easily tokenize and require special techniques.
  - While AI is improving with spreadsheets (e.g., OpenAI’s agent mode can now create Excel sheets), it’s still not as advanced as Word document processing.
  - Accuracy with numbers in large spreadsheets is not guaranteed without specialized tools like data rails, if you value that accuracy.
- Tier C: Data Lake Scale Data
  - This involves massive, complex, and structured data, like hundreds of thousands or millions of rows of time series data.
  - Traditional LLM transformer architectures do not perform well with this kind of data directly.
  - Instead, LLMs are typically “hooked up” to data lakes by searching the data lake to retrieve useful pieces of information that can then be processed and laddered into insights. It is quite difficult to pivot and architect AI solutions over data lakes.
Implications for AI Use:
- The easier data is to tokenize, the more control you have over architecting AI solutions and your destiny with AI.
- If you can sketch the complexity of a task on a napkin, it’s a good sign AI can be helpful; if you can’t, it may be too complex for AI to handle with nuance. Questions about whether data is too big for the context window, or if the task is too multifaceted or complex for nuance, are downstream of whether the data is tokenizable.
Practical Application:
- To practice, find something you can tokenize this week, and perhaps something you haven’t tokenized. An example of tokenization could be visually processing handwritten notes into text.

2. What is jagged intelligence in AI?

Jagged intelligence means AI is brilliant at some things and surprisingly bad at others. It can reason like Einstein in one area, then trip over something a bad intern would catch, like comparing 9.9 and 9.11, or nailing your tone. Better prompts and a high quality bar smooth out the jagged edges.

Definition of Jagged Intelligence:
- AI exhibits intelligence that is not continuous. It can be as smart as Einstein in some areas and worse than a very bad intern in others.
- It has really, really large gaps in its capabilities.
Key Issues Driving Jagged Intelligence:
- Memory limitations are a primary known issue. AI cannot learn as it goes if it cannot remember.
- AI needs to be retold information repeatedly for assignments (e.g., your role, task instructions), because it is difficult for AI to consistently do certain simple things that require memory.
- It is extremely sensitive to mistakes in instructions or briefings. The AI is like a “Shakespeare who is just obsessed with following instructions” and will make mistakes if the instructions are flawed.
Examples of Low Points in AI Intelligence:
- Math: While specialized models exist for complex math problems (like Math Olympiad problems from Gemini or OpenAI), general LLMs can still struggle with basic numerical comparisons (e.g., 9.9 vs. 9.11). They often call other tools to perform mathematical operations.
- Nuance and Tone: AI can be very good at outlining but may struggle to capture desired tone. The speaker is very picky about tone and feels the AI falls short.
- Deep Strategic Insight: AI can be a good sounding board for strategy, but its insights may cluster around existing distributions (e.g., McKenzie decks) and lack deep originality. It doesn’t feel as refined as needed for strategy. Deep insight only occurs if given exceptionally strong strategic intent and excellent context to reason across your specific information.
Mitigating Jagged Intelligence:
- Better prompting can make jagged intelligence less jagged by effectively communicating intent. Prompting matters significantly to get the LLM to do what it does best.
- Cultivating “high taste”: Recognizing where AI falls short and insisting on a higher quality bar helps you become sensitive to its limitations. You likely know something better than the AI and can push for improvement. If you can’t sense jagged intelligence, it might mean you haven’t insisted on a high enough bar with the AI.
Practical Application:
- Look for areas where AI feels “jagged” and intentionally cultivate its strengths (the “Shakespeare” part) rather than focusing on its less intelligent aspects.

3. When should you use a big prompt vs. a casual chat?

Use a big, detailed prompt when you already know the shape of the work and it needs to be anchored in lots of context. Use short, casual prompts when you’re exploring, brainstorming, or don’t know yet what you want. Both can do meaningful work. Match the prompt to the project.

The Nuance of Prompting:
- The choice between a “big prompt” and a “casual chat” is more nuanced than simply equating important tasks with big prompts.
- Meaningful work can be done with both short and long prompts, depending on the task’s nature.
When to Use a Big Prompt (Formal, Anchored):
- When you have an important task that needs to be done.
- When the task needs to be anchored around a lot of specific context that you provide.
- For focused production where you already know the shape of the work.
- For formal brainstorming sessions where you have context and want to constrain the AI and set your assumptions, similar to a formal human brainstorming session.
- A big prompt sets a strategic intent at the top within a defined conversation box. The planning and thoughtfulness pay off here.
When to Use a Shorter/Iterative Prompt (Casual, Exploratory):
- When you need to iterate and discover as you go.
- For tasks that are iterative in nature, where you are discovering meaning with the AI. It makes sense to start shorter with less intent.
- When you want to riff, brainstorm, and think through things, allowing the model room to expand.
- When you don’t yet know the shape of the work and need to explore it.
- Similar to having casual “drinks after work” conversations for brainstorming with humans.
Practical Application:
- Pay attention to whether the prompt fits the project.
- If you consistently feel like the prompt isn’t right, it’s a signal to rethink how you communicate intent and whether you should iterate for value (shorter prompts) or anchor and define first (bigger prompts).
- The goal is to know when to use a larger, more formal prompt versus a casual one, rather than thinking you always have to write big prompts.

Stop Clicking Like a Human; Use API-Style Automation!

Hey there! Joe Glines here from the-Automator.com and the AutoHotkey YouTube channel.

If you’ve ever come to us wanting to “automate like a human” – sending mouse clicks or keystrokes – you’re not alone. In fact, that’s how most people start: it’s fast, easy, and feels intuitive. But here’s the thing… if you want rock-solid, sharable, long-lasting automation, imitating a human just won’t cut it. Let me show you why moving to API‑style automation is a smarter move. ⬇️

1. Human-like Input = Fragile

Position-based clicks break easily – If someone moves their window or changes screen resolution, your script can’t find that button anymore.
Timing issues – Networks slow, loading screens lag… suddenly your script clicks on the wrong place or types into the wrong control.
Keystrokes get lost – Alt+Tab, pop-ups, unexpected UI… suddenly your automation is sending text into Roblox or Notepad instead of the app you wanted.
Computer and app updates – If the UI shifts, renames, or repaints, your script stops dead.

In short: if it feels rude trying to coordinate UI elements that don’t cooperate, chances are your users will feel it too.

2. API-Style Automation = Durable

APIs allow you to talk directly to programs or controls – no guessing required. Here’s how:

COM Objects

Many Windows apps (like Excel) support COM. You bypass the screen entirely and manipulate the file directly:


excel := ComObjCreate("Excel.Application")
excel.Visible := True
wb := excel.Workbooks.Add()
wb.Worksheets(1).Range("A1").Value := "Hello, AHK!"

ControlSend / ControlClick

Inbox commands that target controls by handle or name. These don’t depend on window position or focus – even hidden controls work.

SendMessage / PostMessage / DLLCall

Talk to an app the way OS itself does. Super reliable once you understand the message IDs.

AutoHotkey’s UIA (User Interface Automation)

This is how AHK v2 gives you insight into buttons, lists, trees… all by properties, not screen pixels. You can search a window for a button named “Save” and click it programmatically:


UIA := UIA_Get("Notepad")
SaveBtn := UIA.Control.FindFirst("Name", "Save")
SaveBtn.Invoke()

It’s precise, robust across layouts, responsive to slow-loads, and generally easier to maintain.

3. Why you should go API-first

✅ Benefit	API-Style	Human-Style
Not tied to screen layout	✅	❌
Works if window is minimized or hidden	✅	❌
Robust to timing/UI changes	✅	❌
Easy to share & run on other systems	✅	❌
Easier to maintain & update	✅	❌

APIs were designed with automation in mind – not because you didn’t know how to click. When you send a control message or COM command, you’re speaking the app’s language. And guess what? That’s cheaper and easier in the long run.

4. So, when should you click like a human?

When no API or COM is available
For apps that don’t expose meaningful controls
As a last resort… and even then… use pixel‑search loops and fail safes

Otherwise: think API-first. Learn COM. Explore ControlSend, UIA. Identify object names and handles, don’t eyeball a button. Trust me, the more you build this way, the more future-proof your scripts become.

In summary

“Click like a human” is quick to prototype—but brittle and slow to fix.
API methods are more robust, shareable, and maintainable.
Invest the extra 10% effort upfront now, and reap the 100% reward later.

Next Steps

Already using COM or UIA? Share your wins—and pain points!
Not sure where to start? No worries—check out our AutoHotkey YouTube tutorials and blog posts on COM, UIA, DLLCalls, and more.

Ready to ditch fragile clicks and build something bulletproof?
Grab a free guide or training on the-Automator.com, and learn how to wield COM, UIA, and ControlSend like a pro.

P.S. Want help automating a particularly tricky app? Just hit reply and let’s figure it out together—you’ll be surprised how fast you’ll feel like a scripting ninja.

Category: AutoHotKey