How I AI: Jason Levin's Workflows for Agentic Memes, Vibe Coding, and Hardware Hacking

Jason Levin built Memelord from a $6.90 meme newsletter into an API business by treating humor like infrastructure instead of brand decoration. In this episode of How I AI, he shows the systems behind that approach: agents that draft memes from trending formats, marketers shipping their own lead-gen tools, a Raspberry Pi keyboard for capturing ideas in bed, and calendar reviews that act like a lightweight chief of staff.

Jason’s core argument is that agents are becoming users. Memelord spent real effort on onboarding and visual polish, but he thinks the winning experience increasingly looks like pasting an API key into an environment file and letting an agent handle the rest. His workflows give AI the repetitive work, speed, and volume while keeping publishing decisions, taste, and risk management with humans.

The workflows range from internet marketing to highly personal hardware hacks, but they share the same pattern: identify a repeated annoyance, build the smallest thing that removes it, and avoid over-generalizing too early. Several of the tools exist only because Jason personally wanted them.

Using agents to draft fast-moving meme marketing

Memes expire quickly, which makes them awkward for traditional content workflows. By the time a social team notices a trend, drafts copy, routes approvals, and publishes, the joke is often already dead. Jason uses an OpenClaw agent connected to the Memelord API to compress that cycle into a conversational workflow.

In the demo, the agent searched Memelord’s trending meme database, selected relevant templates, and generated caption options tied to current events and internet discourse. The important distinction was that the system produced candidate jokes, not autonomous publishing. Humans still reviewed whether the reference made sense, whether the tone fit the audience, and whether the joke was worth associating with a brand. See Automate Meme Marketing with an AI Agent and OpenClaw.

The setup Jason demonstrated

1. 1. Create a Memelord API key with only the permissions the agent actually needs. The goal is to keep the integration narrow instead of handing broad account access to a general-purpose assistant.
2. 2. Store the credential in the agent environment rather than embedding it in prompts or source code, then install the Memelord skill so the agent can call the API directly.
3. 3. Give the agent a topic, current event, or cultural reference and ask for meme candidates. In the episode, Jason and I discussed how useful this becomes for staying on top of fast-moving trends that are difficult for humans to monitor continuously.

Can you cook me up a meme about mimetic warfare?

1. 4. Review the output before distribution. Jason specifically checked the selected template, caption quality, factual context, and overall tone. The agent could also generate alternate captions on demand, which turned the workflow into more of a writers’ room than a one-shot generator.

Why the API layer changes the product

One of the more interesting parts of this episode of How I AI is the shift from designing for humans to designing for agents. I pointed out that Memelord’s onboarding and branding are intentionally human and personality-driven, but the actual product usage increasingly happens through APIs and skills.

Jason described building the OpenClaw skill by asking the coding agent how to build the skill itself, then publishing it without involving engineering. That workflow would have sounded absurdly optimistic a year ago. Here it becomes normal: the product is no longer only the interface. It is the API structure, the defaults, the prompt scaffolding, and the amount of friction between an idea and an executable action.

The result is a system that can generate many more meme drafts than a person would manually create, while still relying on humans for judgment, context, and publishing restraint.

Giving marketers direct access to software creation

Jason’s broader company philosophy is that marketers should build software themselves instead of waiting for engineering prioritization cycles. At Memelord, marketers are expected to use coding agents and prototype ideas directly in Cursor.

That changes the economics of experimentation. Instead of debating whether a lead-generation idea deserves roadmap time, the team can build a small working version in a day and see if people actually use it.

Jason said Memelord’s free tools section generated hundreds of thousands of email sign-ups through lightweight utilities and meme generators. That result is specific to Memelord’s audience and distribution style, but the underlying idea is broadly useful: small interactive tools can outperform static lead magnets because they solve a tiny problem immediately instead of promising value later. You can follow the full implementation in Build Free Marketing Tools as Lead Magnets Using AI Code Assistants. See Build Free Marketing Tools as Lead Magnets Using AI Code Assistants.

What the team actually uses

• • Cursor is the main editor. The team uses it to generate code, explain unfamiliar systems, debug issues, and prototype ideas quickly enough that non-engineers can meaningfully contribute.
• • The process starts with a narrow audience problem. Instead of planning a large product, the team builds the smallest possible tool that tests whether people care.
• • One example was a Bust Down Filter that unexpectedly spread on TikTok in Turkey after users started sharing it socially.
• • Another was a Steve Jobs-style portrait generator that Jason now uses when pitching journalists and preparing media assets.
• • The team also rebuilt Snapchat-style captioning because Jason found the actual Snapchat interface cluttered and frustrating for simple meme editing.

How to apply this approach

1. 1. Give non-engineering teams explicit permission to experiment, including budget for tokens and a lightweight review process for shipping ideas.
2. 2. Start with a small problem adjacent to the main product rather than trying to replace the product itself.
3. 3. Describe the interface and desired behavior clearly to the coding agent. I noted that Cursor’s ask and debug modes are particularly approachable for non-technical operators because they explain what the code is doing instead of hiding it completely.
4. 4. Before publishing, still review the boring but important details: privacy, analytics, abuse prevention, accessibility, and ownership of any user data the tool collects.

The operational lesson here is bigger than the individual tools. Jason repeatedly argued that organizations lose creative energy when every idea gets routed through multiple layers of translation and prioritization. Giving marketers direct access to coding agents reduces that lossiness.

The tradeoff is that companies still need engineering and security standards. A joke generator is low risk. Anything involving authentication, payments, personal data, or production infrastructure still benefits from experienced review.

Building a keyboard just for bedtime ideas

The most memorable workflow in the episode might also be the narrowest. Jason wanted a way to capture late-night ideas without bringing a phone into the bedroom, turning on a bright screen, or waking his wife by speaking to a voice assistant.

Instead of adapting his behavior to existing devices, he built a dedicated one-purpose input system around a cheap keyboard and Raspberry Pi. See Build a Custom Bedside Keyboard for Idea Capture with Raspberry Pi and ChatGPT.

The path to the final setup

• • The original goal was simple: quietly capture ideas from bed before forgetting them.
• • His first attempt used Google Home voice commands to create reminders, but speaking aloud at night created obvious household problems.
• • He then connected Zapier automations to the voice workflow so the ideas could route into email or task systems, but the interaction still depended on talking.
• • The final solution was removing the screen entirely and replacing voice with a dedicated keyboard that only performs one job.

How the bedside system works

1. 1. Connect a small standalone keyboard to a Raspberry Pi dedicated to this workflow.
2. 2. Run a Python script that captures keystrokes only on this isolated device and session. Jason explicitly framed this as a controlled personal setup. Running generalized keylogging software on shared systems would create serious privacy and security problems.
3. 3. Treat the Enter key as the intentional submit action, then clear the local buffer after sending the note.
4. 4. Send the captured text to a private Zapier webhook using stored credentials and encrypted transport.
5. 5. Route the note based on prefixes typed at the start of the message.

• • Typing Lin Eng creates a Linear task for the engineering queue.
• • Typing email sends the note directly to Jason’s inbox.
• • Messages without a prefix follow the default configured action.

What makes this workflow effective is how intentionally constrained it is. Jason did not try to build a startup or a general-purpose consumer device. He built a personal tool around one recurring annoyance.

That narrowness also keeps the risk understandable. The hardware owner, input source, automation path, and destinations are all controlled. Any workflow that captures keystrokes should maintain those boundaries explicitly.

Using agents as a lightweight executive assistant

Jason also uses agents to review his calendar twice a week and surface patterns he would otherwise miss. The workflow behaves less like a scheduler and more like an analytical assistant looking for recurring inefficiencies.

The two scheduled reviews

The automation runs on a fixed cadence rather than continuously interrupting him:

1. 1. Friday reviews summarize the previous week and analyze where time was actually spent.
2. 2. Sunday reviews look ahead at the upcoming calendar and identify conflicts, overloaded schedules, or missing deep-work blocks.

Suggestions instead of automatic edits

The important design decision is that the agent recommends actions but does not silently change the calendar.

• • In one example, the system suggested Jason stop attending every engineering standup and rely on updates from the CTO instead.
• • It also flagged weeks where nearly all available time had been consumed by meetings, leaving almost no protected focus time.
• • Jason was also experimenting with prompts that identify meetings likely to be replaced by email. Any cancellations or attendee-facing changes still remain behind explicit human approval.

This kind of analysis becomes useful very quickly because calendars already contain structured information about priorities, habits, and relationships. It also introduces real sensitivity around access control.

Jason mentioned potential future integrations with health signals and meeting analysis, but those extensions require much more careful consent and data handling decisions. Calendar automation works best when the agent receives the minimum access necessary to generate recommendations.

What actually makes these workflows work

Across all four workflows, Jason uses AI less as a replacement for human work and more as a force multiplier for experimentation. Agents generate more meme options, coding assistants shorten the path from idea to prototype, and automations surface patterns that are tedious to review manually.

The human still decides what is funny, what ships publicly, what belongs on the calendar, and what risks are acceptable.

The strongest ideas in this episode of How I AI are the ones that stay intentionally narrow. The meme workflow is useful because it creates fast reviewable drafts, not autonomous brand publishing. The marketing tools work because they solve small audience problems quickly enough to test demand. The bedside keyboard succeeds precisely because Jason never tried to turn it into a universal product. "Let your marketers cook" works best when teams can experiment freely but still maintain clear approval gates for anything customer-facing, security-sensitive, or reputationally consequential.