DEV Community: AIRabbit

I Scraped 301 Job Ads for $1.75 — The Top Employer Was a Bot

AIRabbit — Thu, 13 Aug 2026 10:23:54 +0000

I had forty one tabs open and no idea whether the job market was good or bad.

Was I missing Kubernetes, or German? Were these real companies, or the same recruiter over and over?

No idea. And that's not a discipline problem — it's a format problem.

Every question I cared about was an aggregate question, and you can't answer one of those by scrolling.

So I turned the board into a table. Here's everything I typed:

LinkedIn jobs: AI engineer, Berlin

301 postings. 38 seconds. $1.75.

I didn't write a scraper or touch a single selector.

What's actually running

Three pieces, and only one of them is you.

Piece	Job
Apify	Hosts ~100 pre-built scrapers ("actors") and keeps them working
The `apify-ultimate-scraper` skill	Tells Claude which actor to pick and how to drive it
You	Say what you want, in English

It's a skill, not an MCP server — a folder of instructions Claude reads before running the Apify CLI on your behalf.

You never touch the CLI.

Setup: two commands, once

npm install -g apify-cli
apify login

The free tier gives you $5/month in credits, which is a few thousand rows. apify login opens a browser.

Install the skill after that and you can forget all of this exists.

The prompt

This is the whole interface.

LinkedIn jobs: AI engineer, Berlin

Behind that line, Claude picked an actor and looked up its input schema. It ran four paginated jobs, noticed two came back empty, and retried them.

Then it deduped 350 rows down to 301 and wrote the CSV.

I watched it happen without typing a command.

The follow-ups matter more than the scrape

The scrape is one line. What I asked next is where the answers came from, because at that point I was talking to a table instead of a feed.

The prompts I actually used, in order:

how many of these are actually in Berlin vs remote-EU?

what % of the descriptions mention German? use word boundaries,
"rag" is matching "storage"

group by company — who's posting the most?

pull out every posting with a salary band, sort by top of range

Each took a few seconds. None of them are answerable on the site itself.

The shift is going from "how do I scrape this" to "what do I want to know."

Steering it when it goes sideways

A few things that got me unstuck:

Situation	What to say
Run returns nothing	`the run succeeded but returned 0 rows — check the log`
Wrong actor	`that actor needs account permissions, find one that doesn't`
Suspicious numbers	`use word boundaries, not substring matching`
Want more	`pull pages 2 through 4 and dedupe on job_id`

The second one came up immediately. My first actor needed a one-time permission grant in the Apify Console — Claude hit the error, said so, and switched.

The third one is the mistake I'd have shipped. Substring rag matches "sto*rag*e", which quietly doubled my number.

And worth knowing: SUCCEEDED doesn't mean it worked. An empty dataset that finishes in three seconds is a failed run with a green checkmark on it. Ask for the log, not the status.

Finding 1: "Berlin" isn't Berlin

Germany (nationwide)     96
Berlin, Berlin, Germany  69
European Union           59
Berlin, Germany          38
EMEA                     27

109 of 301 are actually in Berlin.

Work type says the same thing: 216 Remote, 52 Hybrid, 33 On-site.

"Berlin" is a filter that returns Europe.

Finding 2: Agents ate RAG

Skill	% of 301
Python	65%
LLMs	52%
agentic / AI agents	36%
AWS	30%
RAG	25%
Kubernetes	21%
PyTorch	14%
TensorFlow	11%
PhD	5%

PyTorch and TensorFlow combined only tie RAG on its own.

This market is asking for API wiring and production infra, not model training.

Kubernetes looks like a better use of a weekend than backprop.

Finding 3: German blocks less than you'd think

78% of postings never mention German.

If you're hunting in Berlin without it, that's more useful than any advice I'd read on the subject.

And it's invisible from the search page.

Finding 4: the top employer is a bot

15  Hire Feed
 9  THRYVE
 5  Jobgether
 4  dexter health / SNI / Quik Hire Staffing

Hire Feed posted 15 roles. Senior AI Software Engineer (Remote) EMEA. ML Engineer (Remote) EMEA. DevOps Engineer (Infrastructure) EMEA.

A recruiter aggregator, carpet-bombing the feed.

You can't spot this by scrolling — not because you're not paying attention, but because the platform interleaves those 15 among hundreds.

One group by and it's sitting right there.

Bonus: salary, where it's public

38 of 301 listed a band.

duvo.ai      AI Platform Engineer (EU remote)  €110K–220K
vCluster     AI Infrastructure Engineer        $150K–200K
PulseRise    Voice AI Engineer                  €85K–160K
HiveMQ       Senior AI Fullstack Engineer       €58K–110K

Platform and infra top the range, not the model roles.

And the biggest numbers are in USD — US companies hiring into Europe.

When not to do this

The honest one first: I did this more for fun than out of necessity.

Nobody needed these numbers. I could have opened the site and applied to things like a normal person.

If you're actively hunting, an hour of applications beats an hour of questions.

What I got was the pleasure of turning a vague feeling into a table, plus four facts I wouldn't have noticed otherwise.

That's a real payoff. It just isn't a need, and a guide that pretends otherwise is selling you something.

The rest is more practical:

You need private data. No gated profiles, no emails, no connection graph. Public only.
You need complete fields. applicant_count was on 113 of 301 rows. skills was empty on nearly all of them. Public pages are lossy.
You're scraping people, not postings. Job ads are corporate content. 500 individuals' profiles is a GDPR problem wearing the same clothes.
You need it to be allowed. This breaks LinkedIn's ToS. Bans are the normal outcome, not the edge case. hiQ v. LinkedIn means it isn't a CFAA crime in the US — it doesn't make it contract-legal.

Connect Your AI to the Hidden Web in Seconds using this Insane AI

AIRabbit — Thu, 13 Aug 2026 10:10:49 +0000

One of the most impressive capabilities of AI is its ability to take vast amounts of unstructured data and distil it into clear, actionable insights.

If we consider how AI acquires knowledge, it exists on a spectrum.

Ungrounded (pre-training): pure parametric knowledge, i.e. what the model has learned during training or thinks it knows
Basic web search: better grounded, but still prone to noise, outdated pages or superficial information scattered across the open web.
Deep research: features built into modern AI providers (such as ChatGPT, Gemini and Perplexity) that provide more in-depth search results.

However, even today's "deep research" isn't nearly as in-depth as you might think.

If you ask your favourite AI to conduct deep research on a specific LinkedIn post, Instagram feed or private community page, it will return something — but if you inspect the output closely, you'll be surprised by how superficial it actually is.

Why does Deep Research fail here?

The reason is simple. AI models primarily crawl the publicly available web that is indexed by search engines. They struggle with 'walled gardens' — platforms that actively block scrapers, require logins or restrict public API access, such as LinkedIn, Instagram, X, Meetup and specialised forums.

Although platforms such as Reddit have entered into lucrative licensing agreements with AI companies to share their data, most major social platforms remain inaccessible. At best, an AI model may capture residual data fragments that have leaked onto public Google index pages, but it rarely captures the full picture, such as complete comment threads, full user metadata or engagement lists.

Try it yourself

Open your favourite AI tool and ask it to retrieve all the underlying data for this link, such as post comments and full engagement metadata Link.

It will almost certainly fail or hallucinate details.

The Traditional Solution (And Why People Didn't Use It)

Technical readers will instantly recognize the classic fix: web scrapers.

Market leaders such as Apify and Bright Data solved the access problem a long time ago. Apify provides users with access to hundreds of specialised, developer-built scrapers that can navigate protected APIs and web structures on platforms such as LinkedIn, X and Instagram.

So why hasn't everyone been using web scrapers to power their AI queries?

Historically, it was too technical. Users had to manually search for the correct scraper ('Actor'), configure complex JSON parameters, manage API keys, track computing costs and clean the raw output data themselves.

A long time ago, Apify provided an MCP interface for its entire platform, but it was still too tedious to use, even for technical users. There are several reasons for this, including:

The selection process for actors is based on various factors such as cost and reliability.
the heterogeneous schemas of actors (each actor has its own input and output formats)
Aggregating and processing vast amounts of data returned can be problematic. It can be enormous, and feeding all of it into your AI is not a good idea

And, frankly, many more problems besides.

But recently, Apify came up with a few solutions to address exactly those issues.

The Game-Changers: MCP and Apify AI

Apify recognized these friction points and introduced two major solutions to eliminate the technical barrier:

Model Context Protocol (MCP) Integration: An MCP tool mcp ultimate scraper handles the heavy lifting directly within your AI workflow. It automatically selects reliable scrapers based on your budget, parses your prompt parameters, and feeds clean data straight back into your agent.
Apify AI: A zero-setup feature that turns natural language questions into scraped, structured answers automatically.

With Apify AI, you ask a question that your standard AI model can't answer due to missing web data, and Apify’s AI engine figures out how to fetch the answer itself using its vast scraper marketplace.

You can find all the details about this amazing new feature here:

https://docs.apify.com/account/apify-ai

How Apify AI processes your query:

Breaks down your prompt to determine the target platforms (LinkedIn, Instagram, X, etc.).
Searches the Apify Actor marketplace for the best tool.
Checks community ratings and performance.
Maps your prompt requirements to the scraper’s required inputs.
Configures and executes the run behind the scenes.
Reads, parses, and synthesizes the scraped results into a final answer.

For example, you can ask prompts like:

"Find all decision-makers who commented on this post and summarize their titles."
"Extract user profile details and engagement metrics for this specific handle."

Step-by-Step Walkthrough

Imagine you posted a product announcement on LinkedIn, got a wave of engagement, and want to know who those people actually are without spending hours clicking through profiles manually.

(Note: For this demonstration, we picked a random public profile to test the workflow.)

Step 1: Open the AI Chat

First, navigate to the Apify Console and open the AI chat prompt.

Step 2: Enter Your Prompt

Enter your request in plain English, and let Apify AI break down the logic and select the right Actor automatically.

Step 3: Automated Execution & Evaluation

In a few seconds or minutes, the AI recognizes when the scraping run finishes and begins evaluating the raw dataset.

Step 4: Inspect the Underlying Data

You can track real-time logs and inspect the structured underlying data on the left panel.

Step 5: Dig Deeper & Integrate

From here, you can ask follow-up questions, export datasets, or set up integrations. For instance, you can automatically send the scraped results to Google Drive or NotebookLM to synthesize deep reports, visualize trends, or build customized knowledge bases.

Final Thoughts

This strategic move by Apify dramatically lowers the barrier to entry for web scraping. What used to require developer knowledge can now be accomplished by anyone with a simple text prompt.

We are only scratching the surface of what’s possible. In upcoming posts, we’ll dive even deeper into advanced features like custom MCP setups and utilizing the Ultimate Scraper tool. Stay tuned!

Stop Choosing AI Models Based on Twitter Hype (And How to Automate It)

AIRabbit — Sat, 08 Aug 2026 16:57:01 +0000

Here is how 90% of engineering teams pick an AI model: someone remembers a tutorial, sees a viral tweet, or pastes a model slug into a config file. Then, nobody touches it for a year.

That laziness is expensive. The gap between a fashionable model and the right model is often a 5–10x difference in API costs—or the difference between an agent loop that completes in seconds and one that hangs indefinitely.

Before you panic: don't worry. You do not need to manually evaluate benchmark suites, test 400 models yourself, or analyze endless spreadsheets. And no, you don't have to switch away from your favorite coding tools like Claude Code, Cursor, or ChatGPT.

Bear with me—there is a way to let AI handle this entire selection process automatically. By connecting OpenRouter’s MCP server via simple OAuth in your browser, your primary assistant (like Claude) can query catalog metrics, select the optimal model, and delegate fast, cheap sub-tasks to it on the fly—at scale, with zero friction.

The Two Questions Developers Fail to Separate

When evaluating models, you have to separate two fundamental questions:

"Is this model any good?" This is an inherent property of the model's capabilities. It does not change based on who hosts it.
"Can I run it—and at what price and speed?" This is a deployment property. A single open-weights model can have up to five different hosting options, each with different prices, latencies, and context limits.

To make smart decisions without extra work, you rely on two data sources:

Artificial Analysis answers Question 1. They run an independent, standardized benchmark suite across all major models (measuring reasoning, coding, and agentic tool use) so you get objective scores across vendors.
OpenRouter answers Question 2. They aggregate hundreds of models behind a single unified API with real-time pricing, context limits, and capability flags.

If you rely solely on standard metrics like speed or popularity, you run the risk of shipping a fast 470 ms model that gives completely wrong answers. You need both quality benchmarks and deployment specs working together.

The Math: High Benchmarks vs. True Cost-Efficiency

Consider this snapshot of measured intelligence across top models:

Model	Intelligence Index	Coding Index	Prompt Price
`anthropic/claude-opus-5`	63.1	78.0	$5/M
`openai/gpt-5.6-sol`	60.9	77.4	$5/M
`moonshotai/kimi-k3`	59.7	76.2	$3/M
`qwen/qwen3.8-max`	58.1	71.8	$2/M
`openai/gpt-5.6-terra`	56.6	76.7	$1/M

Look closely at gpt-5.6-terra:

It ranks 5th overall in general intelligence (56.6).
For coding tasks, its score (76.7) is just 1.3 points below the top-tier leader (78.0).
The cost: $1/M prompt tokens versus $5/M for the top model.

If you blindly pick the headline benchmark leader, you pay a 5x markup for a negligible 1.3-point increase in coding performance.

The right question is never "What scores highest?"

The right question is: "What is the cheapest model that meets my minimum quality floor?"

Zero-Setup Selection: How Your AI Handles It

You don't need to write custom integration code or manage API keys manually just to run models.

By connecting OpenRouter's MCP (Model Context Protocol) server to Claude Code, Cursor, or ChatGPT, authentication happens seamlessly via OAuth in your browser. Once authorized, your assistant gains direct, native access to OpenRouter's full catalog—which embeds Artificial Analysis benchmark scores right inside it.

Reading the catalog data is completely free. You can paste a prompt into your assistant, let it inspect real-time benchmark scores and pricing, and decide on the best candidate before spending a single dollar.

View Prompt: Copy-Paste Selection Prompt for Your AI Agent

Paste this into Claude Code, Cursor, or your AI assistant to let it query the catalog and pick the right model for your task:

Pick the best model for this job: .
My constraints: .

Use OpenRouter's model catalog via MCP/API. It carries Artificial Analysis benchmark scores
inside it, so one query gives you both quality and price. Do NOT recommend a
model from memory — show me the query and its output.

1. Say which Artificial Analysis index matches this job and why:
   - intelligence_index → open-ended reasoning, analysis, explanation
   - coding_index       → generation, refactoring, review
   - agentic_index      → multi-step tool loops (also use min_tool_success_rate)
2. Query with a FLOOR on that index plus my constraints, sorted by price:
   https://openrouter.ai/api/v1/models?min_=&amp;max_price=&amp;sort=pricing-low-to-high
3. Table: model, the relevant index, prompt price, context length. Mark models
   with no Artificial Analysis entry as "not evaluated" — never treat a missing
   score as zero.
4. Recommend the CHEAPEST model that clears the floor, not the highest scorer.
   Tell me what I give up versus the frontier, in index points.
5. List which providers serve it and at what price; say whether pinning one
   with provider: { only: ["..."] } is worth it for latency.
6. Tell me what the indices CANNOT tell me about my task, and what I should
   test myself before committing.

Technical Deep Dive: Raw Querying & Host Pinning

Free Catalog CLI Query

If you prefer inspecting raw catalog JSON via terminal scripts, getting a free API key at openrouter.ai/keys lets you query the catalog for free:

curl -s "https://openrouter.ai/api/v1/models?min_coding_index=50&amp;max_price=1&amp;sort=pricing-low-to-high" \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  | jq -r '.data[] | [.id, (.benchmarks.artificial_analysis.coding_index // "-"), .pricing.prompt] | @tsv' \
  | column -t

Available filter parameters include:

min_intelligence_index
min_coding_index
min_agentic_index
min_tool_success_rate (a 0.0 to 1.0 ratio predicting whether multi-step agent loops complete reliably)
max_price
context
supported_parameters

Deployment Pinning & Provider Control

Because open-weights models are hosted by various infrastructure providers (Groq, Together, DeepInfra, etc.), one model slug maps to multiple backends. You can enforce provider pinning directly in payload options for low latency:

const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: {
    "Authorization": `Bearer ${process.env.OPENROUTER_API_KEY}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    model: "meta-llama/llama-3.1-8b-instruct",
    provider: { only: ["Groq"] }, // `sort` is a hint; `only` is binding
    messages: [{ role: "user", content: "Parse this raw text into JSON." }]
  })
});

Note: If provider pinning fails with a No allowed providers are available error, handle it gracefully by falling back to unpinned routing.

Sub-Task Delegation at Scale via MCP

Once OpenRouter’s MCP server is connected via OAuth, your primary assistant isn't just picking models—it can actively call and delegate sub-tasks to them directly through the OpenRouter MCP interface.

This unlocks massive workflow efficiencies:

Claude remains your lead architect: Use top-tier reasoning for complex code design, refactoring, and architectural decisions.
Claude delegates routine execution: Offload repetitive unit test generation, log parsing, or translation tasks to a 10x cheaper, sub-500ms model on OpenRouter automatically.
Access non-text models seamlessly: Commands like "Generate a hero image for this blog post" or "Transcribe this audio file" can be executed directly by your coding agent through MCP, without creating extra vendor accounts or managing separate keys.

The Golden Rule: What Benchmarks Can't Tell You

Filtering by Artificial Analysis benchmarks trims down 400+ raw models into 2 or 3 ideal candidates in seconds. However, generic scores won't tell you:

How a model handles your specific prompt templates.
How well it knows your domain-specific code patterns.
How it handles edge cases in your production environment.

Benchmarks get you 95% of the way there for free. The final step is running your target test cases against those top 2 or 3 survivors.

Testing 3 candidates takes an afternoon. Testing 400 is impossible.

The Formula: Set a quality floor, sort by price, let your AI filter the catalog via MCP, and test the top survivors.

The End of AI Laziness: How Claude for Chrome Changes Browser Automation

AIRabbit — Thu, 05 Feb 2026 16:36:27 +0000

I have been experimenting with AI in browsers for several years now. I have tried almost every tool available including Nano Browser, ChatGPT Agent, Comet, Atlas, Manus, and many others. I have written extensively about these tools and compared their pros and cons in detail. While these agents are becoming more powerful with every release, they still suffer from significant limitations that prevent them from being truly useful for professional workflows.

The most limiting factor as of today is a tendency toward laziness. When tasks become complex or the context window is overloaded, most AI agents fail. They lack the reasoning required to behave like humans. They struggle with basic capabilities like saving files or executing code with caution. They often get lost in the middle of a process and require constant hand holding.

Recently, I revisited an old interest of mine: Anthropic Computer Use. I had early experience with this technology and it was actually the subject of one of my most read articles on Medium. This time, I tested the latest release of the Claude Chrome extension.

The result changed my perspective entirely. Every limitation I experienced in other AI browsers over the last two years has been addressed. In my opinion, this extension makes AI in Chrome a super weapon. It can perform browser automation end to end with incredible reasoning and reliability.

To understand the impact of this tool, consider a highly complex task. Imagine you want to release an app on the App Store. Coding is easier than ever, but managing the signing and publishing process remains a tedious nightmare.

I tried to automate this specific process with all the major tools mentioned above. Every single one failed. They could not navigate the Apple Developer portal or handle the multi step verification required. However, the Claude Chrome extension completed it. It worked from start to finish without any hesitation.

Why This Implementation is Different

Before we look at the specific steps, it is important to understand what this extension actually does. It is not just a chatbot sitting in a sidebar. It is a reasoning engine that can see your browser and interact with it as a human would.

If you want to try this yourself, you need a Claude subscription and a Chromium based browser. For a higher level of security and isolation, I recommend using a separate browser such as open source Chromium.

The setup is simple. Once you download the extension and log in to your account, you are ready to automate. I usually select the cheapest model first. In most cases, Haiku 4.5 is absolutely sufficient for tedious tasks.

Practical Automation: A Case Study

When I use this tool, I provide all instructions at once and let it find its own path. For the App Store task, I needed to create provisioning profiles for an electronic app. This is a lengthy process involving multiple pages and specific security settings.

As with any professional tool, Claude creates a detailed plan and asks for your approval before it begins implementation. This is the same convenient workflow you might know from tools like Cursor or Claude Code. After around seven minutes, the task was finished. This is a feat that no other browser AI has achieved in my testing.

Moving Beyond One Time Tasks

The most powerful feature of this extension is the ability to create scheduled tasks. If you have a process that you perform daily, you can save it. Claude converts the entire chat history into a persistent task.

For example, I created a task to find AI meetups in Berlin. The extension generated a comprehensive description of the goal and the exact steps to achieve it. I can now schedule this to run every morning at 7 am. The results can be saved to my disk, sent via email, or uploaded to a cloud account like Google Drive.

Use Cases for the Modern Professional

There are many theoretical applications for browser automation, but few tools deliver on the promise. With this new level of autonomy, several use cases are now fully viable:

First, accounting tasks like downloading monthly invoices from various portals.
Second, in depth research and data synthesis across multiple sources.
Third, travel planning that involves complex comparisons and booking steps.
Fourth, applying for jobs and managing application trackers.

The extension also includes several advanced capabilities. It can download files such as screenshots and PDFs directly. It can run JavaScript for DOM manipulation. It can even interact with your Gmail to send messages or save files to your Google Drive. These features make real life use cases manageable rather than just theoretical.

If you want to see the exact prompts I used and learn the specific tricks to speed up these automations, you should read the full guide. I have documented the entire setup and the security configurations I use to keep my main browser data safe.

Read the full deep dive here:

Claude for Chrome - The Most Advanced AI Browser You have Ever Seen

airabbit.blog

Turn a Single Prompt into a Full Animation with Nano Banana

AIRabbit — Mon, 26 Jan 2026 19:21:53 +0000

Nano Banana has taken the world by storm and continues to disrupt entire industries, including art, marketing and advertising.

While many people use it to create amazing illustrations, slides and other assets, one capability is often overlooked: image grids.

With this feature, Nano Banana (and ChatGPT to a certain extent) can generate not just one image in response to a prompt, but a series of images arranged in a grid like this:

This amazing capability can be used not just to create images, but also entire animations, advertising videos, tutorials and much more.

In this tutorial, we will demonstrate an exciting use case: creating an assembly video or animation with just one prompt using Nano Banana on BudgetPixel.

If you don't already have a BudgetPixel account, feel free to create one here.

Step 1: Set Up Your Project

Head to the Image Studio as shown below and select Nano Banana.

Next, enter this prompt and update the placeholder [PRODUCT NAME + short description]

Create a consistent step-by-step product assembly as a sequence of 8 frames.
Keep EVERYTHING identical across all frames: camera angle, focal length, lighting, background, table surface, color palette, shadows, and object positions (except the newly added part).
Style: clean studio product photography, softbox lighting, high detail, realistic materials, sharp focus.
Scene: top-down 3/4 angle on a matte white workbench with subtle texture.
Main product (final goal): [PRODUCT NAME + short description].
Parts: [list key parts]. Tools allowed: [tools].

Frame progression (only the new change per frame):

Lay out all parts neatly, labeled with small unobtrusive tags A, B, C…

Place the base/chassis in the center.

Attach part A to the base (show fasteners if used).

Attach part B (do not move previously attached parts).

Insert internal component C (show precise alignment).

Add external cover/shell D (snap/slide into place).

Tighten/lock final connections (small visible detail only).

Final fully assembled product hero shot, same camera position.

Constraints (must follow):

Do not change background, camera position, crop, lighting, or color temperature.

Do not add extra objects, hands, or new tools unless listed.

No text overlays except the small part labels in frame 1.

No deformation: product shape, logo, and materials must remain consistent.

There are lots of other parameters that can be adjusted, such as the resolution, aspect ratio and number of images.

For this tutorial, however, we will stick with the defaults.

For more advanced scenarios, I recommend trying to generate with higher resolution (to get better resolution in the final animation) and letting BudgetPixel generate multiple variations to choose from.

Step 2: Generate the Grid

Now, head to the Generate button at the bottom of the page.

I go grab a cup of coffee and a few minutes later, we have the image grid. At first glance, it looks quite consistent and super realistic.

Step 3: Create the Animation

Now, download this image and head to the Image Cutter—a free open-source tool on Hugging Face that can create an animation from this image grid in a few seconds.

https://huggingface.co/spaces/airabbitX/image-cutter

Select the proper rows and columns, then click Cut Image.

After a few seconds, you should be able to see the extracted images at the bottom of the page.

Now head to Export, click "Single tile per frame," and then click Generate GIF.

Please note that you can also download the extracted images separately as a zip file. In this tutorial, however, we want to generate an animation in the export tab.

Now, finally, you can download the animation.

With this approach, you can create powerful animations for your products in minutes.

Bonus Tips

Feel free to also upload your product images to Nano Banana as a reference. You can do this in the img2img tab.

Finally, if you want to edit the image, you can do that with ease to crop, upscale, or remove the background.

Happy animation! :)

Audit Your Mac Permissions: Find Hidden Access You Forgot About

AIRabbit — Mon, 12 Jan 2026 11:25:08 +0000

Apple's privacy system is one of the most robust in the world, giving you granular control over which apps can access your camera, files and microphone. But here's the problem: with hundreds of different settings ranging from camera access to voice and personal folders, it's nearly impossible to remember what you've actually granted.

Over months or years of use, you suffer from "permission creep" – unintentionally granting access to an app that doesn't really need it, or forgetting about a setting you changed for a one-time task. That Google Chrome camera permission from last year? Still there. The Zoom microphone access you enabled for a single meeting? Probably still active.

Leaving these permissions open isn't just digital clutter. It's a genuine security risk. But most people have no practical way to see their entire permission landscape at once.

The good news? There's a simple way to export your complete permission database and use AI to automatically flag dangerous settings you missed. And you won't need any external tools – just your terminal and a smart AI like Claude or ChatGPT.

Here's How to Do It

Step 1: Access Your Hidden Permission Database

macOS stores all your app permissions in a database called TCC.db. Open Terminal and run this single command:

sqlite3 ~/Library/Application\ Support/com.apple.TCC/TCC.db "SELECT * FROM access"

This outputs your entire permission database in raw format. It will look like cryptic gibberish at first, but that's exactly what AI is designed to organize and interpret.

Step 2: Feed Your Data to an AI Auditor

Copy the entire output from your terminal. Paste it into Claude, ChatGPT, or your preferred AI tool. But don't stop there. You need to give the AI proper context so it understands what those database entries actually mean.

Provide a detailed prompt that explains the TCC.db structure. Ask the AI to identify which permissions are unusual, which apps shouldn't need camera or microphone access, and which settings represent potential security gaps.

Step 3: Review the Analysis

The AI will organize everything into readable tables and highlight suspicious entries. You'll immediately spot things like:

• Chrome having camera permissions you never intentionally granted
• Obscure apps with full disk access
• Old applications still retaining microphone permissions
• Unexpected access to your calendar, contacts, or photos

Step 4: Revoke Unnecessary Permissions

Head to System Settings on your Mac. Navigate to Privacy and Security. Find each app the AI flagged and toggle off any permissions it shouldn't have. Use the official Apple interface rather than modifying the database directly, which ensures system stability.

What This Method Actually Reveals

This audit gives you visibility into nearly every restricted resource on your Mac:

Media and Hardware: Camera, Microphone, Bluetooth, Media Library, Screen Recording

Personal Data: Photos, Reminders, Calendars, Contacts, Focus Status, Full Disk Access

Files and Folders: Documents, Downloads, Desktop, iCloud Drive, Network Volumes

System Control: AppleEvents (which lets apps control other applications)

Why This Matters

Most Mac users never check their permissions after granting them. That means old apps, untrustworthy applications, and software you no longer use often retain access to your most sensitive data indefinitely. A single compromised app with camera permission can spy on you. An app with full disk access can steal your financial documents.

This five-minute audit shifts you from hoping you're secure to actually knowing which apps have access to your private life. It's the difference between trusting Apple's security system and actively managing it.

Visit the full article at airabbit.blog for the complete AI prompt template and step-by-step screenshots.

Cursor MCP Model Context Protocol: The Ultimate Guide to Infinite Context

AIRabbit — Sun, 11 Jan 2026 16:34:50 +0000

The biggest bottleneck in AI coding isn't model intelligence—it's context.

Until now, if you wanted Cursor (or any AI editor) to know about your database schema, internal documentation, or live server logs, you had to manually copy-paste that information into the chat window. It was tedious, error-prone, and quickly hit token limits.

Enter the Model Context Protocol (MCP).

In this guide, we'll cover everything you need to know about using MCP in Cursor, from basic configuration to building your own custom MCP servers. We'll go deeper than the official docs, providing working code examples and real-world strategies to supercharge your workflow.

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an open standard that enables AI models to "reach out" and interact with external data and tools.

Think of it like a USB port for AI. Instead of trying to stuff the entire internet into the model's training data, MCP provides a standard way for the model to query data on demand.

Why this changes everything for developers:

Live Data: Your AI can query your actual Postgres database to see the current schema, not a hallucinated one.
Security: You don't paste API keys or sensitive customer data into the chat. The MCP server handles the connection locally.
Scalability: You can connect tools that have terabytes of data (like logs or huge docs) without worrying about context window limits. The AI simply searches for what it needs.

Part 1: Setting Up MCP in Cursor

Cursor has built-in support for MCP. It acts as an MCP Client, allowing it to connect to any MCP Server.

1. Prerequisites

Cursor version 0.41 or higher.
Node.js installed (if you plan to run JavaScript-based servers).
Bun (recommended for the fastest local development).

2. The `mcp.json` Configuration File

Cursor looks for an mcp.json file to know which servers to connect to. You can place this file in two locations:

Global: ~/.cursor/mcp.json (Tools available in all projects)
Project: .cursor/mcp.json (Tools specific to the current repo)

Here is a robust starter configuration:

{
  "mcpServers": {
    "sqlite": {
      "command": "uvx",
      "args": ["mcp-server-sqlite", "--db-path", "./my-database.db"]
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/username/desktop"]
    }
  }
}

Pro Tip: Use uvx (from uv) or npx to run servers without manually installing them globally. It keeps your environment clean.

3. Verification

Once configured, open Cursor and go to Cursor Settings > Features > MCP. You should see a list of connected servers with a green "Connected" status.

Part 2: Building a Custom MCP Server (TypeScript)

While pre-built servers are great, the real power comes from building your own. Let's build a practical "DevOps Helper" server. This server will give Cursor the ability to check the status of websites—perfect for debugging connectivity issues without leaving the editor.

Step 1: Initialize the Project

mkdir my-mcp-server
cd my-mcp-server
npm init -y
npm install @modelcontextprotocol/sdk zod
npm install -D typescript @types/node
npx tsc --init

Step 2: Create the Server (`index.ts`)

We will use the generic McpServer class to define a tool.

#!/usr/bin/env node
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";

// Create the server instance
const server = new McpServer({
  name: "devops-helper",
  version: "1.0.0",
});

// Define a tool: "check_website_status"
server.tool(
  "check_website_status",
  "Checks if a website is reachable and returns its status code and response time.",
  {
    url: z.string().url().describe("The full URL to check (e.g., https://google.com)"),
  },
  async ({ url }) => {
    try {
      const start = Date.now();
      const response = await fetch(url);
      const duration = Date.now() - start;

      return {
        content: [
          {
            type: "text",
            text: `Status: ${response.status} ${response.statusText}\nTime: ${duration}ms`,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error connecting to ${url}: ${(error as Error).message}`,
          },
        ],
        isError: true,
      };
    }
  }
);

// Connect via Stdio (Standard Input/Output)
async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
  console.error("DevOps Helper MCP Server running on stdio...");
}

main().catch((error) => {
  console.error("Fatal error:", error);
  process.exit(1);
});

Step 3: Build and Configure

Add a build script to your package.json:

"scripts": {
  "build": "tsc",
  "start": "node dist/index.js"
}

Run npm run build.

Step 4: Connect to Cursor

Update your .cursor/mcp.json to point to your new server. Note: Use absolute paths for stability.

{
  "mcpServers": {
    "devops-helper": {
      "command": "node",
      "args": ["/ABSOLUTE/PATH/TO/my-mcp-server/dist/index.js"]
    }
  }
}

Now, in Cursor Chat (Cmd+L), you can ask:

"Is https://cursor.com down right now?"

Cursor will automatically call your check_website_status tool and report the result.

Part 3: Advanced Techniques

1. Resources vs. Tools

The example above used a Tool (function execution). MCP also supports Resources (reading data).

Use Tools when: You need to perform an action (API call, database write) or calculate something dynamic.
Use Resources when: You want to expose static or file-like data (logs, documentation files, database schema).

2. Environment Variables & Security

Never hardcode API keys. Cursor's mcp.json supports environment variable interpolation.

{
  "mcpServers": {
    "github-mcp": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${env:MY_GITHUB_TOKEN}"
      }
    }
  }
}

3. Debugging with MCP Inspector

If your server isn't showing up or acting weird, use the MCP Inspector. It's a web interface to test your server manually.

npx @modelcontextprotocol/inspector node dist/index.js

This launches a UI at localhost:5173 where you can manually invoke tools and see the raw JSON-RPC messages.

Comparison: MCP vs. "Context" Features

Many developers ask: "Why use MCP if Cursor already has @Codebase indexing?"

Feature	Cursor `@Codebase`	Cursor + MCP
Data Source	Static local files	Live databases, APIs, logs, external tools
Freshness	Updated on file save	Real-time (milliseconds old)
Capability	Read-only	Can execute actions (create Jira tickets, restart pods)
Privacy	Uploads code embeddings	Data stays local (for local MCP servers)

Conclusion

The Model Context Protocol transforms Cursor from a smart text editor into a full-stack operational console. By configuring a few simple JSON files, you can give your AI agent permission to check your production DB, read your internal wikis, and debug your APIs—all without leaving the IDE.

What is an MCP Server? The Complete Guide to the "USB-C for AI"

AIRabbit — Sun, 11 Jan 2026 16:28:27 +0000

If you've tried connecting Claude or ChatGPT to your local files, database, or internal tools, you’ve likely hit a wall. You either have to paste context manually (which is tedious) or build fragile, custom API integrations (which is hard to maintain).

Enter the Model Context Protocol (MCP).

MCP is a new open standard that acts as a "universal driver" for AI. Instead of building a custom integration for every AI model, you build one MCP Server, and any MCP-compliant AI (like Claude Desktop, Cursor, or IDEs) can instantly use your data and tools.

In this comprehensive guide, we’ll cover:

What an MCP Server is (and how it differs from a REST API).
The 3 Core Components: Resources, Tools, and Prompts.
Real-World Use Cases: Why developers are switching to MCP.
Tutorial: How to build a "System Monitor" MCP Server in Python in 5 minutes.

What is an MCP Server?

An MCP Server is a lightweight application that standardizes how data and tools are exposed to AI models.

Think of it like a USB-C port for Artificial Intelligence.

The Host: The AI application (e.g., Claude Desktop, Cursor, VS Code).
The Protocol: MCP (Model Context Protocol).
The Server: Your custom adapter (e.g., "PostgreSQL MCP Server", "Google Drive MCP Server").

Before MCP, if you wanted Claude to query your database, you had to wait for Anthropic to build a "Database Plugin." Now, you can just run a local MCP Server, and Claude can query your database immediately—without sending your credentials to the cloud.

Architecture: Host vs. Client vs. Server

It’s important to distinguish the roles:

MCP Host: The app the human interacts with (e.g., Claude Desktop).
MCP Client: The internal connector within the Host that speaks the protocol.
MCP Server: The standalone process (running on your machine or remotely) that actually has the data.

The 3 Pillars of an MCP Server

An MCP Server isn't just a data pipe; it exposes three distinct capabilities to the AI:

1. Resources (Passive Context)

Resources are like files. They provide data that the AI can read to understand the current state.

Example: A log file, a database schema, or the current price of Bitcoin.
Protocol: system://logs/error.txt
Use Case: "Read the error log to see why the build failed."

2. Tools (Active Capabilities)

Tools are functions the AI can execute. They take inputs and return outputs, often changing the state of the system.

Example: execute_sql_query(query), send_slack_message(channel, text).
Safety: Tools often require explicit user approval ("Allow Claude to run this command?").
Use Case: "Fix the bug and restart the server."

3. Prompts (Reusable Workflows)

Prompts are pre-written templates that guide the AI on how to use the server.

Example: A "Debug Incident" prompt that automatically loads the last 50 log lines (Resource) and asks the AI to analyze them.
Use Case: standardized workflows for team members.

MCP Server vs. REST API

Why do we need a new standard? Why not just use OpenAPI/Swagger?

Feature	REST API	MCP Server
Primary Consumer	Human Developers	AI Models
Discovery	Static Documentation	Dynamic Handshake (JSON-RPC)
State	Stateless (usually)	Context-Aware
Data Format	JSON	Text/Markdown (Optimized for LLM Context Windows)
Goal	CRUD Operations	Providing Meaning & Action

The Key Difference: A REST API returns raw data. An MCP Server returns context—data formatted specifically for an LLM to understand and act upon.

Tutorial: Build Your First MCP Server (Python)

Let’s build a System Monitor MCP Server. This server will allow Claude to:

Read your computer's CPU and Memory usage.
List files in any directory you ask for.

Step 1: Installation

You'll need Python 3.10 or higher. Install the official MCP SDK:

pip install mcp

Step 2: The Code (`system_server.py`)

We will use FastMCP, a high-level API that makes building servers incredibly simple.

from mcp.server.fastmcp import FastMCP
import psutil
import os
import datetime

# 1. Initialize the Server
mcp = FastMCP("My System Monitor")

# --- RESOURCES: Data the AI can read ---
@mcp.resource("system://stats")
def get_system_stats() -> str:
    """Returns real-time CPU and Memory usage statistics."""
    cpu = psutil.cpu_percent(interval=0.1)
    memory = psutil.virtual_memory()

    return f"""
    --- SYSTEM STATS SNAPSHOT ---
    Timestamp: {datetime.datetime.now()}
    CPU Usage: {cpu}%
    Memory Total: {memory.total / (1024**3):.2f} GB
    Memory Used: {memory.used / (1024**3):.2f} GB ({memory.percent}%)
    """

# --- TOOLS: Actions the AI can take ---
@mcp.tool()
def list_directory(path: str) -> str:
    """
    Lists all files and folders in a specific directory path.
    Args:
        path: The absolute path to the directory (e.g., /tmp)
    """
    if not os.path.exists(path):
        return f"Error: Path '{path}' does not exist."

    try:
        items = os.listdir(path)
        # Return a clean list formatted for the AI
        return "\n".join([f"- {item}" for item in items])
    except PermissionError:
        return f"Error: Permission denied for accessing '{path}'."

# --- PROMPTS: Reusable templates ---
@mcp.prompt()
def check_health():
    """Ask the AI to analyze system health."""
    return [
        {
            "role": "user",
            "content": "Please check the 'system://stats' resource and tell me if the system is under heavy load."
        }
    ]

if __name__ == "__main__":
    # This runs the server over Stdio (Standard Input/Output)
    mcp.run()

Step 3: Connect to Claude Desktop

To use this server, you need to tell Claude where it is.

Open or create your Claude config file:
- Mac: ~/Library/Application Support/Claude/claude_desktop_config.json
- Windows: %APPDATA%\Claude\claude_desktop_config.json

Add the configuration:

{
  "mcpServers": {
    "my-monitor": {
      "command": "python",
      "args": ["/ABSOLUTE/PATH/TO/system_server.py"]
    }
  }
}

(Note: Replace /ABSOLUTE/PATH/TO/ with the actual path to your file).

Restart Claude Desktop.

Step 4: Test It!

Look for the plug icon 🔌 in the Claude input bar. It should now show "My System Monitor".

Try asking:

"What is my current CPU usage?"
"Please list the files in my Downloads folder."

Claude will automatically call your Python functions, get the data, and answer you naturally!

Security Best Practices

Because MCP servers can execute code and read files, security is critical.

Local First: Run servers locally (localhost) whenever possible. This ensures your data never leaves your network until the AI processes it.
Human Approval: By default, Claude Desktop asks for permission before running any Tool. Do not disable this for sensitive tools like delete_file or execute_sql.
Read-Only Resources: Prefer exposing data as Resources (passive) rather than Tools (active) whenever possible, as Resources are generally safer.

Summary

MCP Servers are the future of AI integration. They replace fragile "glue code" with a standardized protocol that makes your data AI-ready.

Resources give the AI eyes (read access).
Tools give the AI hands (write access).
Prompts give the AI instructions (workflows).

By building a simple MCP server, you turn a generic LLM into a specialized assistant that actually knows your system.

Kill the Dashboard: Chat Directly With Your Google Analytics Data

AIRabbit — Thu, 08 Jan 2026 10:51:29 +0000

Most people use AI to generate text. Power users use AI to analyze reality.

By connecting an LLM to your Google Analytics data via the Model Context Protocol (MCP), you transform your chat window into a command center for your business intelligence.

The Problem with Traditional Analytics

You're logging into Google Analytics, navigating menus, creating custom reports, filtering data by hand. It's repetitive. It's slow. And worst of all—you can only analyze one property at a time.

What if you could ask questions instead?

"Find all pages on my marketing site with high bounce rates but high load times, and suggest technical fixes."

"Which of my websites had the biggest traffic drop this week? Why might that be?"

"Show me pages that are converting well but have slow load times—those are my optimization goldmines."

This isn't theoretical. After this setup, you can ask complex, multi-step questions across every single website under your Google account simultaneously using natural language.

Why This Actually Works

The Model Context Protocol (MCP) is a new standard that lets AI models directly access external data sources. When you connect MCP to Google Analytics, your AI gets real-time access to:

Every property under your account
Live traffic metrics
User behavior patterns
Conversion data
Technical performance stats

The AI can then:

Identify patterns you'd miss manually
Cross-reference data across multiple sites
Suggest actionable improvements
Answer follow-up questions instantly

No more exporting CSVs. No more context switching. Pure data analysis in your chat window.

The Setup Takes ~30 Minutes

Yes, there's OAuth configuration and API setup involved. I won't sugarcoat it—this involves creating credentials and configuring APIs.

But it's really worth it.

Here's what you'll do:

Create a Google Cloud Project
Configure an OAuth consent screen
Generate OAuth credentials (one JSON file)
Authenticate via the Google Cloud CLI
Enable two Analytics APIs
Add the MCP config to your AI client
Test it with a simple query

That's it. Then you're done forever.

What You'll Be Able to Do

After setup, you can ask things like:

✓ Performance Analysis: "Which pages are my biggest traffic drivers but have the worst user experience?"

✓ Anomaly Detection: "Did something break on my site last Tuesday? Show me the metrics."

✓ Conversion Optimization: "Which traffic sources convert best, and how do I get more of them?"

✓ Technical Insights: "Pages with high bounce rates—are they slow? Mobile unfriendly?"

✓ Cross-Site Patterns: "Compare traffic patterns across all my websites. What's different?"

All without touching a dashboard. All in natural language.

Who This Is For

Product managers who need quick data insights without bugging analytics teams
Growth marketers optimizing multiple websites simultaneously
Founders who want to understand their metrics without learning GA4 deeply
Technical teams looking for performance bottlenecks
Anyone tired of clicking through dashboards

What You'll Need

A Google Account with access to at least one GA4 property
Google Cloud SDK installed (free, takes 2 minutes)
~30 minutes of setup time
An MCP-compatible AI client (Claude Desktop, Cherry Studio, etc.)

The Full Guide

I've written a complete step-by-step walkthrough covering:

Detailed screenshots for every step
Troubleshooting tips if you get stuck
Exact terminal commands to run
How to test your connection
Example queries to get started

Read the complete technical guide on airabbit.blog →

Journaling Like a Pro with Logseq, Day One, Daylio, Apple Journal & More

AIRabbit — Wed, 07 Jan 2026 12:54:01 +0000

Before we compare specific apps, here’s what separates genuinely useful journaling tools from the noise.

Speed of entry matters more than you think. Reviews and hands-on testing of the best journaling apps consistently reward tools that let you create an entry with one or two taps or clicks, including getting the keyboard up immediately. If the app creates friction, the habit usually dies.

Privacy and data ownership are deal-breakers for some. Many premium options now include protections like end-to-end encryption, two-factor authentication, and local storage options, with examples and comparisons in this roundup. Open-source tools like Standard Notes and Joplin add transparency, and your data can remain readable even if a company disappears.

Cross-platform synchronization should not be an afterthought. Some apps are built around switching between phone, tablet, and desktop without losing context, as highlighted in cross-device comparisons.

Export functionality is critical. Strong tools make it easy to take your writing with you, including PDF and data exports, and this is a core point in major feature comparisons. Software does not last forever, your words should outlive the app.

With these principles in mind, here are the actual contenders.

Logseq: The Thinking Engine for Linked Notes

Best for: People who want to connect ideas across entries, quick daily capture, and privacy

If you treat journaling as knowledge-building rather than just venting, Logseq is worth a look. It’s free, open-source, and built around linking.

How Logseq Actually Works

Logseq organizes your work as a knowledge base (“Graph”). When you start a new graph, it creates core folders for journals, pages, and configuration files, which makes it easy to keep daily entries and topic notes in one connected system. You can also run multiple graphs for separate projects or life areas.

The real differentiator is the interaction model. Many long-time note-takers describe the shift as moving from “documents” to “blocks,” where each bullet or paragraph can be rearranged, referenced, embedded elsewhere, or placed onto a whiteboard canvas for visual thinking, with user experience notes and examples here.

The Privacy Angle

Logseq is designed to keep your data local, with an emphasis on user control in many tool comparisons. Like other local-first apps, it stores notes as Markdown so your files remain readable long-term, as discussed in hands-on writeups.

Because Logseq is open-source, you are not locked into a single company’s roadmap, and the project can continue even if development shifts, a point covered in community-focused coverage.

The Trade-Offs

Some workflows can still feel rough, especially mobile sync and whiteboards, and the block-based philosophy takes time to click. Practical limitations and setup notes show up in broader PKM workflow discussions.

Notion: The All-in-One Workspace (If You Don’t Mind Complexity)

Best for: People building custom workspaces, collaboration, and anyone comfortable with databases

Notion is the kitchen sink. It can be a journal, a project manager, a habit tracker, or whatever you build.

Why People Love (and Hate) Notion

Notion shines when you want structure plus collaboration, especially in setups where you share prompts, templates, or entries, with pros/cons outlined in privacy vs collaboration comparisons. Its databases are the main advantage, letting you add properties like mood, energy, tags, and then filter and sort entries. It’s also frequently used for visual knowledge management and AI-assisted search in PKM system guides.

The trade-offs are real: complexity, cloud dependence, and portability concerns are common themes in long-term workflow discussions. Export exists, but moving a highly customized workspace elsewhere is not frictionless.

Pricing Reality

Notion’s free tier is strong, but advanced features require paid plans. It is primarily cloud-based, so full functionality depends on reliable internet access.

Obsidian: The Customization Champion

Best for: People building a personal knowledge management system, those who want maximum plugin flexibility, and writers

Obsidian is built for people who want to shape the tool around their brain.

The Plugin Ecosystem

Obsidian’s biggest advantage is its plugin ecosystem. Popular examples include Dataview-style workflows for querying your notes and building dynamic views, with patterns and examples in PKM setup guides.

Both Logseq and Obsidian are local-first, Markdown-based, and support bidirectional links, with a solid side-by-side breakdown here. Obsidian tends to win on extensibility and the maturity of its plugin and theme ecosystem.

Privacy and Control

Obsidian stores notes as plain text files on your device, which supports longevity and ownership, a point often emphasized in broader digital notebook comparisons. Linking concepts with double brackets creates a personal knowledge graph that evolves over time.

The Reality Check

Community rankings frequently put Obsidian near the top for control and flexibility, with recurring themes summarized in PKM tool breakdowns. The downside is that plugins can become a distraction, and the learning curve is real.

Day One: The Premium All-Arounder

Best for: People willing to pay for polish, Apple users, and those who want a feature-rich journaling experience

Day One is a premium-first journaling app, built for people who want journaling to feel frictionless and polished.

What Day One Delivers

Day One is commonly highlighted for its clean UI and security features in feature roundups. It also ranks highly in broad “best overall” comparisons for cross-platform support and journaling fundamentals, with details in multi-app reviews.

Real Features That Matter

From the official listing: Day One: Daily Journal & Diary

Unlimited text entries with rich text formatting and Markdown support
Multiple journals for separate areas of life
End-to-end encryption for private entries
Automatic backups
Passcode, Touch ID, or Face ID protection
Photos and video support
Cross-platform apps for iPhone, Apple Watch, iPad, and Mac
Voice recording and transcription
Auto-import options for certain social content
“On This Day” memories
Map view for location-tagged entries
Print features to create a physical book

It also supports integrations and automation options, including Health-related tracking and shortcuts, depending on your platform setup.

The AI Angle

Some devices can use on-device AI features for entry titles and prompts, with feature notes included in major app comparisons.

The Cost

Day One has a generous free tier, with premium features behind a subscription.

Daylio: Quick Mood Tracking Without the Writing

Best for: People who want patterns without long-form writing, mood awareness, and fast daily check-ins

Daylio is journaling as logging. That is the whole point.

The No-Writing Advantage

Daylio is built around quick mood + activity tracking, as described in the official listing: Daylio Journal - Daily Diary. You can log moods, attach activities, and review trends over time.

Fast daily check-ins
Custom moods and activities
Charts and statistics across weeks, months, and years
Optional notes when you want more context

Why This Matters

Mood and habit tracking apps can help people notice patterns and correlations, with examples in broader app coverage like this overview and feature-based comparisons such as this roundup. It’s not therapy, but it can be useful data for self-awareness.

The Trade-Off

Daylio is not built for long, detailed narrative journaling, which is a common limitation noted in feature breakdowns.

Privacy and Security

Daylio’s listing describes local privacy controls, optional cloud backup via your own account, and export options: Daylio Journal - Daily Diary.

GoodNotes: The Handwriting Option

Best for: People who prefer handwriting on iPad, digital organization, and Apple Pencil workflows

If typing kills the vibe, handwriting can feel more natural. GoodNotes is not a dedicated journaling app, but it works well for journaling because you can write by hand, organize notebooks, and search handwritten text.

Apple Journal: The Native Approach (iOS/iPadOS/macOS)

Best for: Apple ecosystem users who want a native experience, simplicity, and tight OS integration

Apple’s Journal app focuses on a minimal, native journaling experience. It’s designed to feel like part of the operating system, with optional iCloud syncing depending on your settings. It aims for “write, search, and revisit,” rather than heavy customization.

How to Actually Choose Your Journaling Tool

Stop overthinking it. Use this framework:

First: do you want to write prose or log data?

If you want reflections and narrative entries, look at Day One, Notion, or Obsidian. If you want patterns and mood tracking without writing, look at Daylio or Apple Journal.

Then choose by philosophy:

Privacy-first and open-source: Logseq or Obsidian
Collaboration and flexibility: Notion
Premium experience with rich features: Day One
Fast daily check-ins: Daylio
Handwriting-first: GoodNotes

Finally, consider your ecosystem:

Deep Apple integration: Apple Journal or Day One
Android-friendly: Daylio, Notion, or Logseq
No loyalty: Logseq, Notion, or Obsidian

Try before you commit. Most of these tools have free tiers. Use each for a full week before deciding. The “best” tool is the one you will actually use.

Your AI Isn't Stupid—Your Instructions Are Too Vague

AIRabbit — Wed, 07 Jan 2026 11:24:38 +0000

Last week I pasted a screenshot of a broken UI into an AI assistant. Two buttons were ridiculously huge.

The AI ignored them completely and started talking about something else.

I was shocked. But then I realized: I was asking it to read my mind.

The Real Problem Isn't AI—It's Precision

When your UI gets even slightly complex, you cannot reliably describe what's wrong in a way that makes the model target exactly what you mean. It changes code in the wrong component, edits multiple files, renames things, and suddenly you're debugging the AI's output instead of the actual bug.

This wastes time, wrecks maintainability, introduces bugs, and gets expensive fast.

Three Strategies That Actually Work

After months of frustration, I developed three precision strategies that force AI assistants to hit the target every time:

🎯 Strategy 1: The Inspector Trick

Stop describing UI problems in words. Extract exact element data (selectors, bounding boxes, CSS classes) and feed that to the AI. It's like giving a surgeon GPS coordinates instead of saying "it's somewhere in the chest area."

📖 Strategy 2: The Terminology Document

AI drifts between "Task," "Todo," and "Item" without consistency. Create a single source of truth for what everything is called. One term per concept, enforced everywhere.

🎨 Strategy 3: HTML Variations First

Never redesign in your codebase. Create 3-4 variations in standalone HTML files first, test them visually, then implement the winner. No more refactoring disasters.

The Bottom Line

Stop treating AI like a magic wand. Treat it like a talented junior developer who needs exact specifications. The quality of code you get out is directly proportional to the precision of context you put in.

Want the full implementation details, code examples, and ready-to-use prompts?

👉 Read the complete article here: Your AI Isn't Stupid—Your Instructions Are Too Vague

Includes copy-paste-ready prompts for Cursor, Claude Code, and other vibe coding tools.

Readwise vs Notion vs Obsidian: The Ultimate Knowledge Management Showdown

AIRabbit — Tue, 06 Jan 2026 20:51:45 +0000

In an increasingly information-rich world, managing your knowledge effectively has become essential. Whether you're a researcher, student, avid reader, or professional seeking to organize your thoughts, the tools you choose can significantly impact your productivity and learning outcomes. This comprehensive guide compares three leading platforms: Readwise, Notion, and Obsidian, each offering distinct approaches to knowledge management.

Readwise is a reading comprehension platform designed specifically for people who want to extract maximum value from their reading material. It syncs highlights from popular reading apps like Kindle, Instapaper, and iBooks, then uses spaced repetition techniques to help you review and retain information over time.

Notion is an all-in-one AI-powered workspace that functions as a personal and team knowledge management hub. It combines databases, documents, AI meeting notes, and intelligent search capabilities into one platform, with enterprise-grade features for organizing and accessing information.

Obsidian takes a privacy-first approach to note-taking with local storage and encrypted synchronization. It emphasizes interconnected notes, graph visualization, and an extensive plugin ecosystem that allows users to customize their workflow precisely.

Feature Comparison

Readwise: Highlight Capture & Spaced Repetition

Readwise excels in one primary function: turning your reading highlights into lasting knowledge. Its core features include:

Multi-source Integration: Automatically syncs highlights from Kindle, Instapaper, Apple Books, and other reading platforms
Spaced Repetition Engine: Intelligently schedules daily review of your highlights based on spacing algorithms proven to enhance retention
Smart Tagging & Organization: Automatically categorizes highlights and allows manual tagging for better retrieval
Third-party Exports: Seamlessly pushes highlights to Notion, Obsidian, Evernote, and other tools
Reader Experience: Includes Readwise Reader for distraction-free reading with built-in highlighting capability

The heart of Readwise is its daily review interface, where users encounter carefully selected highlights scheduled for optimal retention. Each day, the system presents a curated selection of your most important passages based on spaced repetition algorithms.

This interface shows the main hub where users interact with their captured highlights. The daily review feature is what makes Readwise unique—rather than passively collecting highlights, it actively brings them back to your attention at scientifically optimal intervals for memory retention.

Beyond daily reviews, Readwise makes it easy to browse your library by books, articles, or custom tags. You can also add highlights manually through text input or photo capture, making it flexible for various reading scenarios whether you're reading ebooks, physical books, or articles online.

What sets Readwise apart is its ability to feed highlights into other tools. Once you've collected highlights, you can seamlessly export them to Notion, Obsidian, or other knowledge management systems, making Readwise an excellent complement to whatever tool you choose for broader knowledge management.

Notion: The All-in-One Workspace

Notion offers a broader ecosystem with versatile features tailored for both individual and team use:

Database & Workspace: Create databases with custom properties, views, and relationships
AI Meeting Notes: Automatic transcription and summarization of meetings
AI Agents: Intelligent agents that help organize and process content automatically
Enterprise Search: Ranked #1 on G2 for knowledge base search functionality
Template Library: Thousands of pre-built templates for various use cases
Collaboration Tools: Real-time collaboration, comments, and permissions management
Content Integration: Embed web content, media, code, and various file types

One of Notion's greatest strengths is how quickly users can get started with existing templates. Whether you're organizing personal tasks, building a team workspace, or creating a complex business dashboard, Notion provides ready-made solutions that can be customized to fit your exact needs.

This task and goal management template demonstrates how Notion's database structure makes it simple to track progress, set deadlines, and manage work items. The flexibility of Notion's database views allows you to see the same information as a table, calendar, kanban board, or timeline—whatever works best for your workflow.

For teams, Notion becomes even more powerful. The collaborative features allow multiple people to work on the same workspace simultaneously, with clear permissions management and comment threads for communication.

This Work Log example shows how Notion can grow with your needs—tracking not just what you did, but categorizing it, tagging skills used, and organizing everything in a logical sidebar structure. This is particularly useful for professionals who need to maintain detailed logs of their work for reflection, documentation, or portfolio building.

Notion's AI features add another layer of power. The platform can automatically generate meeting summaries, organize content, and suggest relationships between pages in your workspace.

For teams specifically, Notion provides dedicated templates for team workspaces that handle common organizational needs: team calendars for visibility, meeting logs for documentation, and structured pages for recording roles, responsibilities, and recurring processes. This makes onboarding new team members faster and ensures everyone knows where to find important information.

Obsidian: Privacy-Focused Note Architecture

Obsidian prioritizes user privacy and flexibility with a powerful local-first approach:

Local Storage: All notes stored locally on your device; no data sent to external servers
Interconnected Notes: Link notes together creating a web of knowledge (backlinks, outgoing links)
Graph Visualization: Visual representation of how your notes connect and relate
Canvas Feature: Infinite whiteboard space for brainstorming and visual organizing
Plugin Ecosystem: Over 1,000 community plugins to extend functionality
Theme Customization: Thousands of themes to personalize your workspace
Cross-device Sync: Optional encrypted sync via Obsidian Sync service
Publishing: Built-in Publish feature to share your notes as a website

What makes Obsidian truly special is its graph visualization feature. This visual representation of your interconnected notes reveals patterns in your thinking and helps you discover unexpected connections between different areas of your knowledge base.

In this example, you can see how a travel planning project in Obsidian creates a dense network of connections—each day of the trip becomes a note, each destination a topic, and Obsidian automatically visualizes how they all relate to each other. This is far more powerful than traditional folder-based organization because you can see your entire knowledge structure at a glance.

The beauty of Obsidian's graph view is that it adapts to your thinking. As you create more connections between notes, the graph naturally evolves, revealing the architecture of your knowledge and helping you spot areas where you might want to add more cross-references or explore deeper relationships.

Each node in the graph can be filtered and explored individually. Clicking on a node shows you all the notes connected to that topic, making navigation intuitive and discovery-oriented. This is a significant advantage for researchers and writers who build complex knowledge systems over time.

Beyond the graph view, Obsidian's Canvas feature provides an infinite whiteboard where you can organize notes visually, perfect for brainstorming or creating visual maps of your ideas. The plugin ecosystem further extends Obsidian's capabilities, with community developers creating tools for everything from productivity tracking to data analysis to integration with external services.

Pricing Comparison

Feature	Readwise	Notion	Obsidian
Free Plan	Yes (30-day trial)	Yes (unlimited for individuals)	Yes
Free Plan Limitations	Time-limited trial	Limited file uploads, basic features	Limited sync options
Premium Individual	$119.99/year	$10-20/month (paid plans)	$39.99/year (optional Sync)
Team/Enterprise	N/A	Custom pricing	Not applicable
Open Source	No	No	No, but privacy-focused

Readwise operates on a straightforward subscription model with a generous free trial period. It's ideal for readers committed to long-term learning.

Notion offers the most flexible pricing with a free tier that covers most individual needs, making it cost-effective for casual users while providing upgrade paths for power users.

Obsidian is essentially free with exceptional functionality, with optional paid services for cloud synchronization and publishing. This makes it highly accessible and attractive to budget-conscious users.

Use Case Analysis

When to Use Readwise

Best For:

Avid readers looking to retain more from books, articles, and long-form content
Students preparing for exams or building knowledge on specific topics
Researchers compiling insights from multiple sources
Anyone using Kindle, Instapaper, or Apple Books as their primary reading platform
Learning-focused professionals seeking continuous self-improvement

Not Ideal For:

Those who don't read frequently or use different reading platforms
Teams needing collaborative documentation
Users requiring extensive personal note-taking beyond highlights

When to Use Notion

Best For:

Teams needing collaborative workspace and documentation
Professionals managing projects, tasks, and information in one place
Organizations requiring enterprise search capabilities
Users wanting AI assistance with meeting notes and content organization
Businesses building internal knowledge bases and wikis

Not Ideal For:

Users prioritizing data privacy and local storage
Those without reliable internet connectivity
Privacy-conscious individuals uncomfortable with cloud storage
Minimalists seeking simplicity over versatility

When to Use Obsidian

Best For:

Privacy-conscious users wanting full control of their data
Writers and academics building interconnected knowledge bases
Users wanting unlimited customization through plugins and themes
Researchers visualizing complex relationships between ideas
Users creating personal wikis and connected thought systems
Remote workers with intermittent internet connectivity

Not Ideal For:

Teams requiring real-time collaboration (without third-party workarounds)
Non-technical users intimidated by customization options
Organizations needing built-in AI or enterprise features
Users expecting a mobile experience equivalent to the desktop version

Detailed Pros and Cons

Readwise

Pros:

Specialized focus on reading comprehension and retention
Seamless integration with major reading platforms
Scientifically-backed spaced repetition methodology
Excellent for building reading habits
Easy export to other knowledge management tools
Free trial allows risk-free testing

Cons:

Limited functionality outside of highlight management
Requires an established reading workflow to provide value
Smaller feature set compared to competitors
No collaborative features
Mobile app functionality is more limited than desktop

Notion

Pros:

Incredibly versatile and adaptable to various workflows
Ranked #1 in enterprise search and knowledge base management
AI features automate content organization and meeting notes
Excellent for teams and collaboration
Generous free plan for individual users
Extensive template community
Fast iteration and regular feature updates

Cons:

Steeper learning curve for complex setups
Can feel overwhelming with too many customization options
Relies on internet connectivity
Data stored on Notion's servers (privacy consideration)
Slower performance with very large workspaces
Mobile experience doesn't match desktop capabilities

Obsidian

Pros:

Complete privacy and data ownership (local storage)
Works offline without limitations
Exceptional performance even with thousands of notes
Powerful interconnection and graph visualization
Infinitely customizable through plugins and themes
No subscription required for core functionality
One-time purchases for optional services
Excellent for long-term knowledge building

Cons:

Steeper learning curve for non-technical users
Limited built-in collaboration features (though possible with third-party sync)
Smaller ecosystem of official features compared to Notion
Mobile experience lags behind desktop
Requires some technical knowledge to fully utilize plugins
No AI features built-in (though plugins may add them)

Integration & Ecosystem

Readwise shines as an integrator, designed to feed highlights into your preferred knowledge management system. It integrates natively with both Notion and Obsidian, making it an excellent complement rather than a replacement.

Notion functions as a hub, connecting with hundreds of external tools through Zapier, API integrations, and native connections. It's designed to be the center of your digital workspace.

Obsidian embraces a plugin-first architecture, allowing community developers to extend functionality and create custom integrations. This makes it highly compatible with other tools through community solutions.

The Verdict: Which Should You Choose?

The answer depends entirely on your primary need:

Choose Readwise if: You're an avid reader wanting to maximize retention from your reading material. It's specialized, focused, and excellent at one thing. Consider pairing it with Notion or Obsidian for broader knowledge management.

Choose Notion if: You need an all-in-one workspace for personal or team use, want AI-powered features, require enterprise search capabilities, or collaborate extensively with others. It's the most versatile option for diverse needs.

Choose Obsidian if: Privacy is paramount, you want complete data ownership, you love customization, or you're building a large interconnected knowledge system. It's the best option for long-term knowledge building with offline capability.

Combination Approach

Many power users employ a hybrid approach: using Readwise to capture highlights from reading, Obsidian for personal knowledge management with interconnected notes (especially privacy-conscious users), and Notion for team collaboration and broader documentation. This combination leverages each tool's strengths while maintaining flexibility.

Conclusion

Readwise, Notion, and Obsidian represent three different philosophies in knowledge management. Readwise focuses on maximizing reading comprehension through spaced repetition. Notion provides an all-in-one, AI-enhanced workspace for individuals and teams. Obsidian prioritizes privacy and customization for building interconnected personal knowledge systems.

Rather than viewing these tools as direct competitors, consider them as complementary components of a knowledge management ecosystem. Your choice should align with your primary workflow, privacy concerns, budget, and collaboration needs. For many users, the optimal solution involves using multiple tools together, each serving its unique purpose.

The best knowledge management system isn't the one with the most features—it's the one you'll actually use consistently. Start with a free trial or the free tier, understand your workflow, and make a decision based on your specific needs rather than theoretical capabilities.

Whether you're a reader, a note-taker, a collaborator, or all three, one of these platforms—or a combination of them—will support your knowledge management goals in 2026.

DEV Community: AIRabbit

I Scraped 301 Job Ads for $1.75 — The Top Employer Was a Bot

What's actually running

Setup: two commands, once

The prompt

The follow-ups matter more than the scrape

Steering it when it goes sideways

Finding 1: "Berlin" isn't Berlin

Finding 2: Agents ate RAG

Finding 3: German blocks less than you'd think

Finding 4: the top employer is a bot

Bonus: salary, where it's public

When not to do this

Connect Your AI to the Hidden Web in Seconds using this Insane AI

Why does Deep Research fail here?

Try it yourself

The Traditional Solution (And Why People Didn't Use It)

The Game-Changers: MCP and Apify AI

Step-by-Step Walkthrough

Step 1: Open the AI Chat

Step 2: Enter Your Prompt

Step 3: Automated Execution & Evaluation

Step 4: Inspect the Underlying Data

Step 5: Dig Deeper & Integrate

Final Thoughts

Stop Choosing AI Models Based on Twitter Hype (And How to Automate It)

The Two Questions Developers Fail to Separate

The Math: High Benchmarks vs. True Cost-Efficiency

Zero-Setup Selection: How Your AI Handles It

Free Catalog CLI Query

Deployment Pinning & Provider Control

Sub-Task Delegation at Scale via MCP

The Golden Rule: What Benchmarks Can't Tell You

The End of AI Laziness: How Claude for Chrome Changes Browser Automation

Why This Implementation is Different

Practical Automation: A Case Study

Moving Beyond One Time Tasks

Use Cases for the Modern Professional

Claude for Chrome - The Most Advanced AI Browser You have Ever Seen

Turn a Single Prompt into a Full Animation with Nano Banana

Step 1: Set Up Your Project

Step 2: Generate the Grid

Step 3: Create the Animation

Bonus Tips

Audit Your Mac Permissions: Find Hidden Access You Forgot About

Here's How to Do It

What This Method Actually Reveals

Why This Matters

Cursor MCP Model Context Protocol: The Ultimate Guide to Infinite Context

What is the Model Context Protocol (MCP)?

Part 1: Setting Up MCP in Cursor

1. Prerequisites

2. The mcp.json Configuration File

3. Verification

Part 2: Building a Custom MCP Server (TypeScript)

Step 1: Initialize the Project

Step 2: Create the Server (index.ts)

Step 3: Build and Configure

Step 4: Connect to Cursor

Part 3: Advanced Techniques

1. Resources vs. Tools

2. Environment Variables & Security

3. Debugging with MCP Inspector

Comparison: MCP vs. "Context" Features

Conclusion

What is an MCP Server? The Complete Guide to the "USB-C for AI"

What is an MCP Server?

Architecture: Host vs. Client vs. Server

The 3 Pillars of an MCP Server

1. Resources (Passive Context)

2. Tools (Active Capabilities)

3. Prompts (Reusable Workflows)

MCP Server vs. REST API

Tutorial: Build Your First MCP Server (Python)

Step 1: Installation

Step 2: The Code (system_server.py)

Step 3: Connect to Claude Desktop

Step 4: Test It!

Security Best Practices

Summary

2. The `mcp.json` Configuration File

Step 2: Create the Server (`index.ts`)

Step 2: The Code (`system_server.py`)