n8n Tutorial

  • Loading...

n8n tutorial - Lesson 16: YouTube Performance Tracker Built in n8n

On
n8n tutorial - Lesson 16: YouTube Performance Tracker Built in n8n

Hi everyone, in this session we build a complete YouTube Performance Tracker in n8n — an n8n analytics workflow that snapshots your channel stats weekly, calculates view and like deltas, and delivers an AI-written report straight to Telegram. This is part of the n8n Workflow Automation Tutorial series and introduces the Snapshot + Delta pattern, one of the most practical techniques for tracking lifetime-only APIs like YouTube Data API v3.

How to do:

Step 1 — Create the History Sheet

Set up a Google Sheet as an append-only history store before touching n8n — every weekly run will add rows here, never overwrite them.
  1. Create a new Google Sheet named T5-Performance-Snapshots (Sheet ID: 1_7qk78gg2pnfAcrDN-JmuT6GXPvMQ3o84k8jqRdgsFk).
  2. Inside the sheet, create a tab named Snapshots with exactly 5 columns: video_id, video_title, snapshot_date, view_count, like_count.
  3. Leave the sheet empty for now — the first workflow run will populate the first 5 rows (one per video). Each subsequent weekly run appends 5 more rows.

Note — YouTube Data API v3 only returns lifetime stats (total views, total likes since upload). There is no built-in "views this week" endpoint. The Snapshot + Delta pattern solves this: save a snapshot each week, then subtract last week's snapshot from this week's to get the weekly delta.

Step 2 — Create the Workflow and Add the Schedule Trigger

Create a new workflow named T5-B4-Performance-Insight and configure it to run automatically every Sunday at 6 PM.
  1. In n8n, create a new workflow and name it T5-B4-Performance-Insight.
  2. Add a Schedule Trigger node. Set the Mode to Custom (Cron) and enter the expression 0 18 * * 0 (Sunday at 18:00).

Step 3 — Fetch the Last Snapshots (Reference Lookup Pattern)

The first two nodes after the trigger load previous snapshot data so the workflow can calculate deltas — this is the reference lookup half of the Snapshot + Delta pattern.
  1. Add a Google Sheets node named Get Last Snapshots. Set Operation to Get Many and point it at the Snapshots tab of your history sheet.
  2. Critical: Enable Always Output Data on this node. This ensures the workflow continues even when the sheet is empty (first run). Without this setting, n8n stops the chain here on week 1.
  3. Add a Code node named Aggregate Last. Set Mode to Run Once for All Items. Write code that:
    • Iterates all snapshot rows and builds a map of videoId → latest snapshot (sort by snapshot_date descending, keep only the most recent entry per video).
    • Outputs a single item: { lastMap: {...}, count: N }.

Production tip — Building a videoId → snapshot map in one Code node gives you O(1) lookup in the downstream Calculate Delta node, instead of looping through all rows for every video. Always use this map pattern for cross-node lookups.

Step 4 — Fetch Current Video Stats from YouTube

Pull the latest video list and stats from YouTube Data API v3 using two HTTP Request nodes, following the same fan-out pattern used in earlier sessions of this n8n tutorial series.
  1. Add an HTTP Request node named Get All Videos. Configure it to call the YouTube search.list endpoint with parameters:
    • channelId: your channel ID
    • order: date
    • maxResults: 50
    • type: video
  2. Add a Split Out node named Split Videos to split the returned items[] array so each video becomes its own item.
  3. Add another HTTP Request node named Get Video Stats. Call the YouTube videos.list endpoint with part=snippet,statistics and pass the videoId from each item. This fans out one HTTP call per video.
  4. Add another Split Out node named Split Stats to unpack the stats items[] returned per video.

Note — Always add a Split Out node after every HTTP list endpoint in n8n. The API returns an array inside a JSON object; without Split Out, downstream nodes receive one item containing the whole array instead of individual items per video.

Step 5 — Flatten Current Stats with a Code Node

Normalize the raw YouTube API response into a clean 5-field structure that matches your history sheet columns.
  1. Add a Code node named Flatten Current. For each item, extract and return:
    • video_id
    • video_title
    • view_count: parseInt() the value (API returns strings)
    • like_count: parseInt() the value
    • snapshot_date: current timestamp in ISO format (new Date().toISOString())

Tip — Always parseInt() YouTube statistics fields. The API returns view counts and like counts as strings, not numbers. If you skip this, delta calculations will produce string concatenation ("1000" + "200") instead of arithmetic.

Step 6 — Branch: Save Snapshots and Calculate Delta in Parallel

After Flatten Current, the workflow splits into two parallel branches — one saves the new snapshot, the other computes the weekly delta.
  1. Branch A — Append New Snapshots:
    • Add a Google Sheets node named Append New Snapshots.
    • Set Operation to Append Row and point it at the Snapshots tab.
    • Enable Auto-Map — the 5 field names from Flatten Current match the column headers exactly.
    • This appends 5 new rows every Sunday, building an audit history that never overwrites past data.
  2. Branch B — Calculate Delta:
    • Add a Code node named Calculate Delta. Set Mode to Run Once for All Items.
    • Inside the code, reference the map from the lookup node: $('Aggregate Last').first().json.lastMap.
    • For each current video item, look up its last snapshot in lastMap. If no entry exists, set is_first_snapshot: true and treat last = 0 so delta equals the current value.
    • Output 5 items, each containing: video_id, video_title, current_views, last_views, delta_views, current_likes, last_likes, delta_likes, is_first_snapshot.

Production tip — The is_first_snapshot flag is essential. Without it, your AI report would say "you gained 50,000 views this week" on week 1, which is misleading — those are lifetime views. Pass this flag to the AI prompt so it can phrase the first report correctly (e.g., "baseline snapshot established").

Step 7 — Aggregate Delta Items into One AI Input

Collect the 5 per-video delta items into a single structured input object for the AI node.
  1. Add a Code node named Build Insight Input. Set Mode to Run Once for All Items.
  2. Inside the code, aggregate all 5 items and output a single item containing:
    • videos_json: the full array of per-video delta objects (serialized as JSON string for the prompt)
    • total_delta_view: sum of all delta_views
    • total_delta_like: sum of all delta_likes
    • is_first_week: true if any video has is_first_snapshot: true
    • snapshot_date_str: formatted date string in DD/MM/YYYY

Step 8 — Generate the Weekly Report with AI

Pass the aggregated input to an AI node that writes a formatted Telegram-ready weekly performance report.
  1. Add a Basic LLM Chain node named Performance Insight.
  2. Configure it:
    • Model: Claude Haiku (claude-haiku-4-5 or equivalent)
    • Temperature: 0.3 (consistent, factual output)
    • Max Tokens: 2000
  3. Write the system/user prompt using 4 XML blocks:
    • <task>: instruct the AI to write a weekly YouTube performance report
    • <telegram_markdown_legacy_syntax>: specify use of legacy Markdown (single * for bold, not **; no V2 syntax)
    • <report_structure>: define the sections (summary, per-video breakdown, top performer, closing note)
    • <input>: inject the dynamic values — {{$json.videos_json}}, {{$json.total_delta_view}}, {{$json.is_first_week}}, {{$json.snapshot_date_str}}

Tip — Always use Telegram Markdown legacy syntax (single *bold*, single _italic_) in your AI prompt — not Markdown V2. Telegram's V2 mode requires escaping nearly every special character, which causes AI-generated text to break formatting unpredictably. Set Parse Mode on the Telegram node to Markdown (not MarkdownV2) to match.

Step 9 — Send the Report to Telegram

Route the AI output to your Telegram channel as the final step of the n8n analytics workflow.
  1. Add a Telegram node named Send Weekly Report.
  2. Select your existing Telegram credential (reuse the personal bot credential created in earlier sessions).
  3. Set Parse Mode to Markdown (legacy, not V2).
  4. Disable Append n8n Attribution to keep the message clean.
  5. Map the message content to {{$json.text}} (or the output field from the LLM Chain node).

Step 10 — Activate and Verify

Activate the workflow and confirm both branches execute correctly on the first run.
  1. Click Active to enable the workflow. It will now run every Sunday at 18:00 automatically.
  2. Run a manual test execution. On the first run (empty sheet), verify:
    • Get Last Snapshots outputs 0 rows but does NOT stop the chain (because Always Output Data is ON).
    • Aggregate Last outputs { lastMap: {}, count: 0 }.
    • Calculate Delta produces 5 items all with is_first_snapshot: true and delta = current.
    • Append New Snapshots writes 5 rows to the sheet.
    • A Telegram message arrives with the weekly report.
  3. Check for the ⚠️ "Credentials for Google OAuth2 API are not set" warning icon on HTTP nodes. If the manual execution succeeds, this is a known n8n UI stale display bug — ignore it.

Note — The warning icon ⚠️ on HTTP nodes saying credentials are not set can appear even when credentials are correctly configured. Always verify by running a manual execution — if it succeeds, the credential is working and the warning is a UI rendering issue in n8n's editor.

Key Lessons from This Session

  1. Always Output Data: ON for reference lookups, OFF for conditional triggers. A node that fetches reference data (like snapshot history) must output an empty item if no data exists, so downstream nodes still run. A node that gates an action (like "get approved rows before sending replies") should stop the chain when empty — turn Always Output Data OFF for those.
  2. Snapshot + Delta is the correct pattern for lifetime-stats APIs. YouTube Data API v3 only returns total lifetime counts. Store weekly snapshots in an append-only sheet, then subtract last week from this week to derive deltas.
  3. Use a Code node to build a lookup map (O(1)) instead of looping. Reference $('NodeName').first().json.mapField in downstream Code nodes for efficient cross-node lookups.
  4. Handle the first-run edge case with an is_first_snapshot flag. Without it, week 1 deltas equal lifetime totals, which produces a misleading AI report.
  5. Always parseInt() YouTube statistics fields. The API returns numeric values as strings; arithmetic operations will silently produce wrong results otherwise.
  6. Add Split Out after every HTTP list endpoint. List APIs return arrays nested inside a JSON wrapper; Split Out unpacks them so each item flows through subsequent nodes individually.
  7. Use Telegram Markdown legacy, not V2. V2 requires escaping special characters and breaks AI-generated text; legacy single-asterisk syntax is far more reliable.
  8. n8n UI ⚠️ credential warnings can be stale bugs. Verify by running a manual execution — success means the credential is fine regardless of what the icon shows.

Conclusion:

In this n8n workflow automation tutorial session, we built a 12-node YouTube Performance Tracker using the Snapshot + Delta pattern — a robust solution for any API that only exposes lifetime statistics. The workflow runs automatically every Sunday, calculates weekly view and like deltas, generates an AI-written report via Claude, and delivers it to Telegram. In the next session (Session 17), we'll build a pipeline that generates SEO descriptions, hashtags, and timestamps for new videos — continuing the progression toward a fully automated YouTube channel management system in n8n.

If you have any questions, feel free to leave a comment below. Thank you!

Tags: n8n analytics workflow, n8n tutorial, n8n workflow automation, YouTube automation n8n, snapshot delta pattern n8n, n8n Google Sheets integration, n8n Telegram bot, YouTube Data API n8n

Maybe you are interested!

Getting Started with Civitai: How to Download AI Image Generation Models

On

Civitai stands out as one of the largest communities for AI image generation, offering a massive repository of models, LoRA files, and resources for creating images, videos, and AI-powered creative content. What makes it particularly appealing is the combination of an intuitive interface and an active user base that's constantly sharing and refining tools for image synthesis.

The platform's real strength lies in its extensive library. You'll find thousands of models and specialized resources designed to produce images across virtually any style you can imagine—from photorealistic portraits and anime to digital art and professional advertising photography. Here's what's interesting: users can browse sample outputs, view the prompts used to create them, and read community feedback before deciding which model suits their needs best.

If you're looking to elevate your AI image quality or explore cutting-edge generation techniques, Civitai deserves your attention. Let's walk through the basics of how to use the platform effectively.

How to Find and Use AI Image Models on Civitai

Step 1:

Head to the Civitai website and create your account.

https://civitai.com/

Step 2:

Once you're in, browse the content using Civitai's category menu. You can search for specific content you want to work with by selecting different categories from the navigation options.

For example, searching for "landscape" will display all image results in that category. When you find an image you're interested in—whether you want to see the model details, explore the prompt, or understand how it was created—simply click on it.

Step 3:

On the right side of the image page, you'll spot the prompt section—this is essentially the command that generated the image in that particular style. Take note of this prompt, copy it, and customize it to match your vision. You can modify keywords and descriptions to create your own unique variations.

Step 4:

Civitai includes a convenient Remix button that lets you generate new images directly using the prompt from the image you're viewing. You'll find this button in the left corner of the interface. Click it to get started.

Keep in mind that generating new images directly on Civitai does consume credits from your account.


Related Articles

How to Use Perplexity's Learn Step by Step Mode: A Complete Guide

On

If you've spent time with Perplexity, you've probably noticed the Learn Step by Step mode tucked into its features. Here's what makes it different: instead of just handing you a final answer, this AI mode walks you through the entire reasoning process, step by step. It's designed to show you not just what the answer is, but how to get there—which is huge if you actually want to understand something.

Think of Learn Step by Step as the teaching mode. It prioritizes guidance and methodical breakdowns over quick answers, making it perfect for students, learners, and anyone diving into new material. The difference from regular Perplexity? Standard mode gives you instant answers. This mode gives you a learning experience. We'll walk you through exactly how to use it below.

Getting Started with Learn Step by Step

Step 1:

Open Perplexity like you normally would. Then type a forward slash (/) and select Learn Step by Step from the menu that appears.

Step 2:

Now enter the topic or problem you want to explore deeply—something that deserves more than a surface-level response.



Perplexity breaks down the response into clear stages designed to build your understanding progressively.

With conceptual topics, Perplexity doesn't stop at definitions and basics. It extends further, offering follow-up angles and deeper questions to explore.

Here's a practical example: try asking it to solve 25 × 16 using Learn Step by Step mode.

Standard mode? You'd get an instant "25 × 16 = 400." But Learn Step by Step is different. It breaks 16 into 10 + 6, then separately calculates 25 × 10 = 250 and 25 × 6 = 150, before adding them together for the final result. What's interesting here is that it's teaching the distributive property without explicitly naming it.

The mode systematically breaks problem-solving into smaller, digestible steps. Rather than dropping an answer on you, Perplexity explains each phase of the reasoning, showing you the mechanics behind it all. You don't just get the result—you understand the logic.

Why Learn Step by Step Actually Matters

Better Learning Outcomes

This feature is tailor-made for students, researchers, and self-learners. Detailed guidance boosts retention and comprehension compared to just reading a final answer.

True Understanding Over Memorization

Learn Step by Step helps you grasp the underlying principles, not just memorize solutions. That means you can apply what you've learned to different scenarios—real learning, not rote repetition.

Cuts Down Research Time

Instead of hunting through multiple sources and documents, you get comprehensive explanations in a single conversation with Perplexity AI.

Works Across Disciplines

It's not limited to math. The mode works effectively for programming, sciences, history, economics, languages, and professional skills too.

When Should You Actually Use It?

Reach for Learn Step by Step in these situations:

  • Solving math problems and working through exercises.
  • Breaking down complex scientific concepts.
  • Learning programming or analyzing code.
  • Understanding workflows and developing new skills.
  • Studying for exams.

Need a quick answer? Use regular mode. But if your goal is to actually learn and build capabilities, Learn Step by Step is the smarter choice. The real concern is not wasting time on answers you could find anywhere—the value is in the explanation.

Related Articles

Monitor AI Usage by App in Windows 11: A Complete Guide

On

Microsoft has rolled out a new section in Windows 11 that lets you see exactly which apps are tapping into the operating system's native AI capabilities for generating text and images. This is genuinely useful—it gives you visibility into what's happening under the hood and puts you in control of which applications can access these AI features.

The feature is available on Windows 11 version 24H2 (Build 26100.5074) and later. You can view third-party apps that have utilized Windows' built-in AI for image creation or text composition. Better yet, you can customize permissions for each individual app. Here's how to make the most of this feature.

How to Check AI Activity History on Windows 11

Step 1:

Press Win + I to open Settings. Once you're in, navigate to the Privacy & Security section on the left sidebar.

Next, scroll down in the right panel and look for Text and image generation. Click on it to see which apps have been using Windows' AI capabilities for image and text creation.


Step 2:

In this new window, select the Recent activity section. Here you'll get a detailed breakdown of which apps have been using AI to generate text or images over the past 7 days.

If no apps have requested these features, you'll simply see "0 requests."

Step 3:

To control which apps can access AI text and image generation, look at the Let apps use Text and image generation section. You'll see a list of apps that currently have permission. What's useful here is that you can revoke access for any app by flipping the toggle switch to the left to disable it.

If you want to turn off AI text and image generation entirely, just disable the Text and image generation setting at the top. Doing this will automatically revoke AI access for all apps on your system.


Related Articles

In the Weights: A New AI Tool That Measures How Well ChatGPT Remembers You

On

For years, Googling your own name has been the standard way to check your internet presence. But now that AI has become millions of people's go-to information source, the whole idea of "looking yourself up" is shifting. More people are asking ChatGPT, Gemini, Claude, and Grok about individuals instead of visiting traditional websites. This raises an interesting question: if AI is becoming the primary gateway to information, do these models actually know who you are?

That's exactly what In the Weights sets out to answer — a new project designed to measure how much of a person's information has actually made it into AI model training data.

What Is In the Weights?

In the Weights was built by Thomas Dimson and Joey Flynn, both former OpenAI employees. The name comes from the weights in AI models — the numerical parameters that determine how a model learns and generates responses.

The tool's goal is straightforward: measure whether an AI model can recognize or recall a specific person without relying on external search tools.

The project's description captures the lighthearted spirit perfectly:

"Being present in the weights of an AI model essentially means your existence was significant enough to shape the development of artificial intelligence."

While more playful than scientifically rigorous, the concept quickly caught the attention of the AI community.

How Does It Work?

To generate your score, In the Weights sends queries to multiple AI models, including Grok, Gemini, various GPT versions, Claude, Llama, and several lesser-known models.

Each model receives the same query:

"Who is <this person's name>? Provide up to 10 results with brief descriptions and confidence levels."

The system then groups similar responses, analyzes how consistent the models are with each other, and calculates a metric called the Strength Score.

In simpler terms: a higher score means more AI models correctly identified the person with strong confidence.

What's interesting here is that In the Weights doesn't measure fame the traditional way — it's not counting social media followers or website traffic. Instead, it reflects how deeply information about a person is embedded in training data and learned by AI models.

The rankings shift constantly. When the project launched, actor Macaulay Culkin (Home Alone fame) was competing with opera legend Luciano Pavarotti for the top spot, both scoring near the maximum threshold.

The real appeal is that you don't just see a final score — you can examine how each individual AI model responded about you, which often reveals surprising differences.

Another notable feature is how the tool catches AI hallucinations. One model, for instance, described "Anthony Ha" as a vague abbreviation that could refer to multiple people, rather than correctly identifying the specific individual being asked about.

These kinds of errors highlight that despite their sophistication, AI models still struggle with accurate person recognition. Different models train on different data sources, leading to wildly different results. That's precisely why In the Weights fascinates the AI community — it exposes how these models actually "see" the world.

What's Next for In the Weights?

The developers initially thought this would be a fun curiosity tool. But demand revealed that plenty of people genuinely want to know whether they exist in AI memory.

Not everyone's convinced, though. Some AI researchers argue In the Weights is essentially just querying multiple chatbots with the same question and aggregating responses. AI researcher Anthony Moser bluntly described it as "asking 13 different chatbots what they know about you."

The development team says they're digging deeper into the collected data. Their research questions include:

  • Why do different versions within the same AI model family produce different results?
  • Which models tend to remember certain demographic groups more accurately?
  • Are there people notable enough to deserve Wikipedia entries but who aren't currently remembered by AI?

These analyses could reveal fascinating insights into how AI models form knowledge and where biases exist in training data.

In the Weights isn't a precise fame-ranking tool or a scientific measure of notoriety. But it does reflect an emerging reality: as chatbots become primary information sources, existing in an AI model's "memory" might become a new form of digital presence.

Being recognized by AI may not be the path to immortality that some joke about. Still, the project raises a genuinely important question about the future of the internet: in the age of AI, will our digital footprints be stored on websites, or embedded in the weights of massive language models?

Related Articles

Getting Started with Artflo AI: Create Images and Videos in One Unified Workspace

On

Artflo.ai stands out as an AI workflow platform built specifically for designers and content creators. Rather than relying on single-command image or video generation, it functions as an integrated canvas where you can chain together multiple AI models and workflows in one seamless environment. What's interesting here is that you're not bouncing between different websites anymore — everything happens in one place.

When you log into Artflo.ai, you'll discover a collection of AI image generators, video creation tools, and content synthesis features. The key advantage? You can combine multiple AI models within a single project without opening separate tabs or platforms. Instead of juggling different tools for each production step, Artflo gives you a visual workspace where multiple AI models work together in your creative pipeline. Here's how to get started building your first workflow on Artflo.

How to Use Artflo AI for Content Creation

Step 1:

Head over to the Artflo AI website using the link below, then create your account to get started.

https://artflo.ai/

Step 2:

Once you're logged in, create a new project to begin your workflow.

Your first move: enter your content description, upload an image, or input a video prompt. You can feed in existing images as your starting material.

Step 3:

Draw a connection line and select what you want to create from the menu shown below. Click on the content type you need from Artflo's available options.

Depending on what you're creating, different tools become available. For instance, you'll access Artflo's image generation tools when working with images.

Here's where it gets powerful: from a single input source, you can spawn multiple outputs simultaneously. Generate both images and videos from the same uploaded content in parallel.

Specify your image dimensions and how many versions you want generated. Once you've configured your settings, hit the Run button to execute the workflow. This consumes credits based on the processing required.

Step 4:

Wait for the AI image generation to complete. Once finished, you'll see your generated images in the results panel. Click the download icon to save your images locally.

The real power emerges here: take these generated images and feed them into your next step. Use text prompts to create the video content you need, all through the supported tools in the interface.

This example shows an image generated using GPT Image-2 on Artflo AI.

Related Articles

What Makes Antigravity 2.0 Stand Out Against Claude in VS Code?

On

Most AI coding tools treat development like a one-way street. You submit a prompt, the model generates code, and you lose all control until it finishes. Even if you know exactly what's going wrong halfway through, you're stuck watching it burn tokens in the wrong direction. The only option? Kill the process and deal with a fragmented workspace. Antigravity 2.0 has solved this problem in ways that put competing tools like Claude on VS Code to shame.

The Old Antigravity Tried to Do Everything Alone

Earlier versions treated you like a spectator, not a developer


A task before execution in Antigravity

Most AI coding assistants work the same basic way everyone's gotten used to. You type a command, hit Enter, and wait. While the model runs, you're completely locked out. Can't edit files, tweak instructions, or ask it to pivot. If you've built anything with Gemini or similar tools, you know this waiting period can drag on.

Sure, you can work on something else while it runs, but that breaks your focus. Things get worse when you hit a logical dead-end. Then it's: ask, wait, review, fix, wait again. The cycle kills momentum and wastes time you don't have.

This was the core problem with original Antigravity and Claude on VS Code. They're still chatbots that wait for instructions before acting and won't let you intervene unless you shut everything down.

What's particularly frustrating is when the model misunderstands your initial request. There's no way to course-correct mid-stream. You just watch it barrel forward, generating code you don't need, searching the wrong directories, heading down a completely wrong path. You can stop it, sure—but often you don't realize the problem until near the end, when you've already burned through your token budget. And abrupt stops are messy. They leave incomplete files and half-finished changes scattered across your workspace, potentially breaking your entire build.

If you're building something complex like a plugin extension, cleaning up broken code is a nightmare. You're deleting snippets, debugging incomplete logic, running git revert—all just to get back to square one. This is one of the biggest reasons Antigravity 2.0 feels like a genuine upgrade.

The Live Comment Feature Is the Real Game-Changer

Here's why Antigravity 2.0 beats Claude on VS Code

Antigravity 2.0 finally lets users control code generation in real-time. Google added a live feedback system that lets you steer and refine output while the agent is working—no interruptions, no resets.

It works through a new live comment feature. Instead of being locked out while code is being written, you can provide instant feedback directly in the workspace. Think of it like a shared Google Doc, where you add comments to specific sections as they're being created.

Spot a function heading in the wrong direction? Don't hit stop. Just flag it for Antigravity. You highlight the problematic block, the agent pauses, reads your note, adjusts course, and continues. You never touch the raw code, nothing gets reset. Antigravity adapts and picks up exactly where it left off.

What's genuinely clever is how contextual this feels. Instead of switching back to a chat dialogue, you're commenting directly on the code in view. When you need to fix something specific, you navigate to that exact line in the Artifact Detail Viewer, open the inline editor with a keyboard shortcut, and leave your feedback.

It's gentle guidance rather than an abrupt kill-switch. Work continues without wasting tokens or time. The model doesn't reply with clarifying messages—it just registers your feedback and adapts. This is exactly why so many developers are switching to Antigravity 2.0 over Claude. Even with generous budgets, API tokens are valuable. Once spent, they're gone. Burning them on recovery work after a hard stop is wasteful. Here's hoping Claude adds similar capability soon.

You Won't Break Anything

It's easy to worry you'll wreck the entire generation process


Antigravity displaying completed tasks with changes

The concern is legitimate. Interrupting mid-generation feels risky—you might break the model's context entirely.

That would be true with older chatbots and especially legacy versions of Antigravity. Stopping an auto-generation mid-fix used to wipe session history, forcing you to start fresh with a new prompt and zero memory of what changed. Essentially, you'd lose everything.

But this isn't a new command. It's not treated as an interruption or stoppage. It's more like editing a shared Google Doc. The model recognizes this as an inline adjustment, not a completely separate request. So nothing breaks. Your feedback is just a gentle nudge, not a full context reset. The model adapts immediately and output stays on track.

It's straightforward and elegant.

This Might Be the Best Feature Ever Added to an IDE Chatbot

Using Antigravity means staying engaged. You're actively watching and reading what it's doing instead of passively sitting back. That's not a problem if you already micromanage your own code, but it could frustrate someone expecting fully automated development. Still, developers will keep choosing Antigravity 2.0 until competitors add the same feature. It's that valuable—especially because it saves so many tokens.

Related Articles

How AI is Reshaping Modern Warfare — And Why That Should Concern Us

On
How AI is Reshaping Modern Warfare — And Why That Should Concern Us

Reports suggest that recent U.S. and Israeli airstrikes targeting Iran relied on Anthropic's Claude AI tool — a striking indicator of how deeply artificial intelligence has woven itself into modern combat. Today, AI influences nearly every phase of military operations: intelligence gathering, tactical planning, even propaganda campaigns. It's a shift that's happening faster than most people realize.

As American and Israeli forces continue military operations against Iranian targets, artificial intelligence has become central to how modern armies wage war.

What's particularly interesting here is the contradiction: the Trump administration and Defense Secretary Pete Hegseth view Anthropic as a supply chain risk, yet the company's AI tools — including Claude — allegedly played a crucial role in these military strikes. The U.S. government seems willing to overlook security concerns when AI gives them tactical advantages.

Multiple sources confirm that AI assisted across the entire operational spectrum. It helped identify targets, supported legal review processes, and even guided strike execution. The result? Decision-making cycles that operate at speeds previously impossible on the battlefield.

Some accounts claim AI was deployed in the initial missile campaigns against Iran, including operations code-named Epic Fury and Roaring Lion. These strikes reportedly resulted in the death of Iran's Supreme Leader Ali Khamenei, who had held power for nearly four decades.

AI Powers Intelligence Analysis and Data Processing

One of the oldest — and most effective — military applications of AI is crunching intelligence data. And it works remarkably well.

The Pentagon's Project Maven stands as a landmark initiative. The system uses machine learning to analyze aerial reconnaissance imagery and sensor data, enabling intelligence officers to spot patterns and objects far faster than humans ever could. Traditional analysis methods become obsolete overnight.

Palantir Technologies, the government contractor behind Project Maven, has long championed AI in military contexts. CEO Alex Karp has consistently emphasized that America must leverage AI to establish strategic advantages in how it deploys forces and understands the battlefield.

Israel's Defense Forces have similarly acknowledged using advanced data analysis systems and AI tools to process intelligence and prioritize targets during operations in Gaza.

The Russia-Ukraine conflict further demonstrates AI's real-world battlefield impact. Both sides have deployed intelligent weapons systems and data analysis tools extensively throughout the conflict.

Autonomous Weapons and the AI Military Debate

Ukrainian forces have gained tactical ground by deploying drones equipped with computer vision and autonomous navigation software. These systems identify and track targets with minimal human input.

The technology is remarkably sophisticated. These drones operate effectively in chaotic combat environments where GPS signals get jammed, making them nearly impossible to neutralize through traditional countermeasures.

Meanwhile, Western defense contractors continue developing loitering munitions — essentially AI-powered kamikaze drones — that can autonomously search for and strike targets like radar systems or armored vehicles.

Despite semi-autonomous weapons becoming commonplace on today's battlefields, Anthropic maintains that fully autonomous weapons systems aren't ready for deployment. This stance has created growing friction between the company and the U.S. government over years-long military collaboration programs.

Dario Amodei, Anthropic's CEO and co-founder, believes AI is vital for protecting America and democratic nations. But here's his concern: current AI systems simply aren't reliable enough to operate fully autonomous weapons independently. The real concern is accountability and safety.

Amodei has stated clearly that Anthropic won't supply products that could endanger soldiers or civilians. He's also mentioned that Anthropic proposed research partnerships with the Pentagon to improve military AI reliability — proposals the government hasn't accepted. His position is straightforward: without proper oversight mechanisms, fully autonomous weapons cannot replace the judgment of trained military personnel.

AI and Deepfakes: The Information Warfare Frontier

In the deepfake era, controlling the narrative across global media has never been easier. When political tensions run high, organized deepfake campaigns can shape public opinion with remarkable speed.

As tensions with Iran escalated, social media flooded with fabricated images and videos. One prominent example showed the USS Abraham Lincoln (CVN-72) supposedly damaged by Iranian attacks.

These fake images forced the U.S. Central Command to publicly debunk the misinformation on X (formerly Twitter). Their statement confirmed the Lincoln suffered no attacks and that Iranian missiles never came close to their target. The carrier continued supporting military operations normally.

Videos circulating widely showed American soldiers returning home in flag-draped caskets. While the images themselves were real, they were recycled from the Iraq War years earlier. Context was stripped away to suggest recent casualties.

Another viral video claimed to show an American fighter jet shot down. Later investigation revealed it was footage from a military video game, not actual combat.

These examples reveal something crucial: AI's role in modern conflict extends far beyond the battlefield. It reaches into cyberspace and information warfare, where AI tools spread political messaging and reshape global public opinion. The real battle might not be won with missiles — it might be won in the minds of people worldwide.

Related Articles

Subscribe to: Posts (Atom)

Copyright © 2016 QTitHow All Rights Reserved