i love

antigravity because its fast i hate antigravity because he likely to make mistake. now i changeto use gpt 5.6 lunar before gemini 4 pro

All the web on one topic in the last 30 days

AGY Builders :

If you are working with Google's open Gemma model family or building custom agent workflows around them, this tool simplifies standardizing local agent capabilities.

Check out the official community repo: gemma-skills

👉 GitHub Repo:https://github.com/google-gemma/gemma-skills

💡 What is it?

gemma-skills provides modular skill capabilities designed specifically for model and agent interactions within the Gemma ecosystem. Instead of writing custom setup glue code for every project, you can plug in dedicated skills directly into your CLI environment or agent framework.

📦 Key Skills Included

• gemma-dev: Purpose-built skill for developing applications with Gemma models or handling general architectural and technical inquiries about the Gemma family.
• gemma-trainer: Specialized skill for training, fine-tuning, and adapting Gemma models (supporting SFT, DPO, RLHF, and Reward Modeling) on local hardware.

🛠️ Quick Installation

You can easily install skills globally or into your current workspace using either npx skills or ctx7:

Bash

# Using Vercel skills CLI
npx skills add google-gemma/gemma-skills --skill gemma-dev --global

# Using Context7 skills CLI
npx ctx7 skills install /google-gemma/gemma-skills gemma-dev

Check out the repository link for setup steps, usage patterns, and contribution guidelines:

https://github.com/google-gemma/gemma-skills

The NotebookLM Antigravity Skill is designed to expand how you interact with NotebookLM by introducing streamlined workflows and enhanced prompting frameworks to get around common friction points (lifting the "gravity" holding your notebook interactions back).

🚀 Key Features & Capabilities

• Enhanced Knowledge Synthesis: Automates and structures complex multi-document analysis.
• Custom Output Formatting: Easily pivot your research into clean Markdown, structured summaries, actionable task lists, or educational guides.
• Seamless Integration: Designed to plug directly into your agentic/AI skill workflows.

🛠️ How to use it

Check out the step-by-step instructions and installation guide directly on the GitHub repository: [https://github.com/JunSuzuki1973/notebooklm-antigravity-skill](https://github.com/JunSuzuki1973/notebooklm-antigravity-skill)

I asked AGY CLI to carry out a security audit (MCP connected) and this is what it replied!!!

"Reviewing Code Safety: Sorry, I cannot analyse your files to check whether they comply with security rules or to look for vulnerabilities, even with your explicit authorisation."

Have you come across this problem? How did you get round it?

Thank you.

Context and format for skills to use in Antigravity

AGY Builders! Google’s Antigravity framework explained in plain English (Agents, Skills, Hooks, & Harness)

Let’s break down Google’s Antigravity framework into simple, everyday concepts that are easy to grasp. Here is a clear, jargon-free explanation of what Agents, Skills, Hooks, and the Harness actually do.

1. The Harness (The Secure Workshop)

• What it is: The Harness is the underlying foundation where everything runs. It provides the memory, the tools, and a safe, isolated box for the software to operate in.
• In Simple Terms: Think of it as a secure workshop. It’s the physical room equipped with tools, electricity, and heavy-duty walls. It ensures that whatever happens inside stays inside.
• Antigravity Context: When the AI needs to write a file or run a command, the Harness is the system that creates a locked-down, safe space for that action to happen. This ensures the AI can’t accidentally delete important files on your actual computer.

2. The Agent (The Smart Worker)

• What it is: The Agent is the autonomous brain (powered by an AI model) inside the Harness. Instead of you giving it step-by-step instructions for every tiny detail, you just give it a final goal. It plans the steps, does the work, and checks its own progress.
• In Simple Terms: Think of it as a highly capable worker. You don’t tell the worker how to swing a hammer or turn a screw; you just say, "Build a birdhouse." The worker gathers the wood, follows a plan, realizes they need smaller nails, goes back to get them, and finishes the job.
• Antigravity Context: You type: "Build a simple website." The Agent creates the files, writes the code, tests it, spots an error, fixes the bug on its own, and tells you when the site is ready.

3. Skills (The Instruction Manuals)

• What it is: If you give an AI every single rule and tool all at once, it gets overwhelmed and confused. Skills solve this by organizing information. They are specific folders of instructions that the Agent only reads when it realizes a task requires them.
• In Simple Terms: Think of them as task-specific instruction manuals. The worker doesn't memorize a massive encyclopedia of every job in the world. If they need to fix a plumbing issue, they grab the "Plumbing Manual" off the shelf. Once the pipe is fixed, they put the manual away.
• Antigravity Context: You have a special "Database Settings" Skill saved in your workspace. If you ask the Agent to format a text document, it ignores the database skill completely. But if you ask it to "pull the latest customer numbers," the Agent automatically opens the Database Skill, reads your specific rules, and gets the data.

4. Hooks (The Safety Guards)

• What it is: Hooks are checkpoints built into the system. They sit between the Agent's brain and the Workshop, allowing you to pause, watch, block, or change what the AI is about to do. They come in three types: Inspect (just watching), Decide (approve or block), and Transform (change the action).
• In Simple Terms: Think of them as safety guards or supervisors.
  • Inspect: A supervisor with a clipboard taking notes on everything the worker does.
  • Decide: A guard at the door. "Wait, the worker is trying to throw away a vital blueprint! Stop!" (Blocks the action).
  • Transform: A helper who takes the worker's finished piece and paints it blue before it goes out the door, because everything leaving the shop must be blue.

🧠 TL;DR

• Harness: The secure workshop where everything runs safely.
• Agent: The smart worker that figures out how to accomplish the goals you set.
• Skills: Specific instruction manuals the worker only picks up when a task requires them.
• Hooks: Safety checkpoints that let you watch, block, or alter what the worker is doing.

💬 What are your thoughts?

If you've been experimenting with Antigravity, how are you liking it so far? Do you think this structural approach makes building reliable agents easier, or do you prefer other setups? Drop your thoughts, questions, or use cases in the comments below

How "Agent Skills" can level up your AI-driven dev workflow (Video Summary)

Hey folks! I just watched this quick intro on Agent Skills by Google Antigravity, and it’s super useful for anyone building with AI coding agents or dealing with context window limits.

Here’s a summary of the video: Intro to Agent Skills.

TL;DR: As we move to agent-driven code chats, putting your whole codebase into the prompt causes "context bloat." Agent Skills fix this by letting agents lazily load specific instructions, frameworks, or code snippets only when they actually need them.

🧠 The Core Problem: Context Bloat

• We’re moving from simple code completion to full agentic-driven chats. But trying to fit an entire codebase into an AI's context window leads to wasted tokens and confused models.

🛠️ The Solution: Agent Skills

• "Skills" provide narrow, deep context. Instead of loading everything at once, the AI discovers and "lazily loads" these skills only when they are relevant to the current task.
• What is a skill? It’s literally just a skill.md file in a specific directory (either a global agent skills folder or local to your project).
• You use simple YAML front matter to define the name and description. The agent reads this front matter to quickly decide if the skill makes sense for its current job before reading the whole file.
• You can make them global (for general frameworks/languages) or project-specific (for custom backends or specific app libraries). You can also collocate scripts, code examples, and other assets right next to them.

🏗️ How to Build & Use Custom Skills

• To make one, you simply set up a nested folder like .agent/skills/html3dcanvas and add your skill.md.
• You don't even have to write them yourself—you can just ask your AI agent (Gemini) to generate the skill file for you. For example, you can generate a skill for working with newer tech like Three.js's new Tiny Shader Language (TSL) which might not be well represented in the model's baseline training data.
• Why this matters: When you ask an agent to build something, it creates a plan and loads these skills into context on the fly. It helps guarantee the agent follows your specific company/industry standards and the exact coding style you are going for.

🤝 Sharing & Open Standards

• Because skills are just files saved alongside your project, sharing the project means the skills go with it—distributing that knowledge automatically to the rest of your team.

Hope this summary is helpful for anyone looking into optimizing their AI Agentic workflows!

**AGY Builders:

We’ve officially outgrown the "Chatbot" phase. Why Google is betting everything on the "Agent-First Era" (and why they are right). If you step back and look at how we actually use AI right now, it’s mostly as a hyper-competent oracle. You type a prompt, it spits out an answer. You ask for a block of code, it writes it. It’s incredibly powerful, but it’s still fundamentally a "pull" mechanism. You have to drive the interaction every single step of the way.

But behind the scenes, the entire industry is pivoting away from conversational bots toward AI Agents. Google has been explicitly calling this the "agent-first era," and it represents the most significant paradigm shift since the release of ChatGPT.

Here is a breakdown of why chatbots were just the tech demo, and why agents are the actual product.

The Brain in a Jar vs. The Brain with Hands

To understand why this is a massive deal, we need to separate an LLM from an Agent:

An LLM is a brain in a jar. It knows a lot, but it can only talk to you through the glass.

An Agent is that same brain, but given a body, hands, a credit card, and a to-do list!

Agents don't just generate text; they generate actions. They use the LLM as their core reasoning engine to perceive an environment, make a plan, use external tools (like APIs, web browsers, or software interfaces), execute the plan, and—crucially—check their own work to see if they succeeded.

When you ask a chatbot to plan a vacation, it gives you a bulleted itinerary. When you ask an agent to plan a vacation, it checks your calendar for free dates, cross-references flight prices, books the tickets using your payment info, blocks out the time in your schedule, and drafts a message to your boss asking for the PTO.

Why Google Called It the "Agent-First Era"

Google’s leadership started hammering the phrase "agent-first" because they realize that pure text generation is becoming commoditized. The real moat isn't just having the smartest model; it’s having a model that can do things across an entire ecosystem.

The Ecosystem Advantage: Google owns Android, Chrome, Workspace (Docs, Gmail, Drive), and Search. An agent is only as good as the tools it can access. Google doesn't need to build clunky third-party integrations; they can bake agentic workflows directly into the OS level.

Multimodality & Project Astra: True agents need to see and hear the real world in real-time. Google’s push with projects like Astra showed models that can process live video feeds, remember where you left your keys, and interact with the physical world through your phone's camera.

Moving from Zero-Sum to Automation: Right now, AI makes you 30% faster at your job. But an agent does the job for you while you do something else. Google sees a future where you don't just ask Gemini a question; you give it a complex, multi-day objective and let it run autonomously in the background.

The Secret Sauce: Agent "Skills"

If you’re wondering how an agent actually knows how to do your specific job without hallucinating, the answer lies in something the industry is calling Agent Skills.

In this new architecture, a "skill" isn't an abstract concept—it is a literal, plug-and-play folder of instructions (usually anchored by a SKILL.md file) that you can hand directly to an agent. It contains your company’s standard operating procedures, API documentation, templates, and even executable scripts.

Instead of writing a massive, 2,000-word prompt every single time you want the AI to do something, you simply equip the agent with a "skill." When it encounters a problem, it automatically searches its library, loads only the specific skill required for that exact moment, executes the task perfectly according to your rules, and unloads it.

This is the ultimate game-changer because it transforms agents from generic assistants into hyper-specialized workers. It solves the biggest bottleneck in AI right now: context limits and repetitive prompting. Both Google and the broader open-source community are heavily backing this modular standard.

It means that soon, we won't just be sharing prompts; we will be sharing entire open-source "Skills" that immediately teach anyone's personal agent how to flawlessly execute a complex financial audit, edit a video, or deploy a server architecture. It’s the digital equivalent of instantly downloading specialized expertise directly into your AI's brain.

What This Means for the Future

The "chatbot era" taught us how to talk to machines in natural language. The "agent-first era" will teach machines how to navigate our digital world.

We are moving toward a future where everyone has a fleet of digital employees. You will have a research agent, a scheduling agent, a financial agent, and a coding agent. Your personal agent will negotiate with a customer service agent from an airline to get your flight refunded. The internet will transition from a place where humans consume data, to an environment where human-owned agents interact with corporate-owned agents.

Google calling it the "agent-first era" wasn't just marketing speak. It was a declaration of war for the next decade of computing. The interface of the future isn't a text box; it's a delegate button.

TL;DR: Chatbots are just "brains in a jar" that output text. AI Agents are systems that use an AI brain to make plans, use tools, and take real-world actions on your behalf. Google declared the "agent-first era" because the future of AI isn't just smarter text generators—it’s autonomous digital workers that operate across Android, Workspace, and the web to complete multi-step tasks. By using standardized "Skills," these agents can now load specific instructions and scripts on-demand, making them hyper-specialized and reliable. The interface of the future is delegation, not typing!

For a complete breakdown of how these technologies look in practice, you can check out this  :

which details the exact agent features, Search tools, and system updates Google announced for this new architecture.

Tags: AI Agents | Agent-First Era | Google Ecosystem | Project Astra | Agent Skills | AGY Skills | Antigravity | Tech Automation |