Communitygithub.com

Anhvu1107/all-agent-skill

Nutze dies immer, wenn die Anfrage zu Astro passt: Erstelle inhaltsfokussierte Webseiten mit Astro – standardmäßig null JavaScript, Inselarchitektur, Multi-Framework-Komponenten und Markdown/MDX-Unterstützung.

Was ist all-agent-skill?

Diese Fähigkeit (Skill) dient als umfassender Leitfaden für die Verwendung von Astro, einem Web-Framework, das für inhaltsreiche Websites wie Blogs, Dokumentationen, Portfolios und E-Commerce optimiert ist. Ihr Kernmerkmal ist die Inselarchitektur, die standardmäßig kein JavaScript an den Browser sendet und interaktive Komponenten nur bei Bedarf hydratisiert. Der Skill behandelt die gesamte Projektstruktur einschließlich dateibasiertem Routing, Inhaltskollektionen für typsichere Markdown/MDX-Dateien und die Integration von UI-Komponenten aus Frameworks wie React, Vue, Svelte und Solid. Er enthält detaillierte Schritt-für-Schritt-Anleitungen von der Projekteinrichtung über die Syntax von `.astro`-Dateien bis hin zur selektiven Hydratation mit `client:`-Direktiven, SSR-Modus mit Adaptern und Best Practices für Performance und Sicherheit. Der Skill ist für Entwickler gedacht, die mit dem Astro-Framework arbeiten, und sollte immer dann verwendet werden, wenn die Aufgabe mit den Stärken von Astro übereinstimmt – insbesondere bei statischen Sites, Inhalten aus Markdown/MDX oder Multi-Framework-Projekten.

Funktioniert mit~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/Anhvu1107/all-agent-skill/tree/HEAD/.agent/skills/astro

In Ihrer bevorzugten KI fragen

Öffnet einen neuen Chat, in dem dieser Agent-Skill bereits geladen ist.

Dokumentation

Astro Web Framework

Selektive Leseregel

Beginne mit:

  • references/senior-master-standard.md
  • references/usage-routing.md
  • references/quality-checklist.md

Lade dann nur die vererbten Dokumente, Skripte, Assets oder Beispiele, die zur tatsächlichen Aufgabe des Benutzers passen.

Überblick

Astro ist ein Web-Framework, das für inhaltsreiche Websites entwickelt wurde – Blogs, Dokumentationen, Portfolios, Marketingseiten und E-Commerce. Seine Kerninnovation ist die Inselarchitektur: Standardmäßig sendet Astro null JavaScript an den Browser. Interaktive Komponenten werden selektiv als isolierte "Inseln" hydratisiert. Astro unterstützt gleichzeitig React, Vue, Svelte, Solid und andere UI-Frameworks im selben Projekt, sodass du das richtige Werkzeug pro Komponente wählen kannst.

Wann dieser Skill verwendet werden sollte

  • Verwende ihn beim Erstellen eines Blogs, einer Dokumentationsseite, einer Marketingseite oder eines Portfolios
  • Verwende ihn, wenn Performance und Core Web Vitals oberste Priorität haben
  • Verwende ihn, wenn das Projekt inhaltsreich mit Markdown- oder MDX-Dateien ist
  • Verwende ihn, wenn du SSG (statische) Ausgabe mit optionalem SSR für dynamische Routen wünschst
  • Verwende ihn, wenn der Benutzer nach .astro-Dateien, Astro.props, Inhaltskollektionen oder client:-Direktiven fragt

Funktionsweise

Schritt 1: Projekteinrichtung

npm create astro@latest my-site
cd my-site
npm install
npm run dev

Füge nach Bedarf Integrationen hinzu:

npx astro add tailwind        # Tailwind CSS
npx astro add react           # React-Komponenten-Unterstützung
npx astro add mdx             # MDX-Unterstützung
npx astro add sitemap         # Automatische sitemap.xml
npx astro add vercel          # Vercel SSR-Adapter

Projektstruktur:

src/
  pages/          ← Dateibasiertes Routing (.astro, .md, .mdx)
  layouts/        ← Wiederverwendbare Seitenhüllen
  components/     ← UI-Komponenten (.astro, .tsx, .vue, usw.)
  content/        ← Typsichere Inhaltskollektionen (Markdown/MDX)
  styles/         ← Globales CSS
public/           ← Statische Assets (werden unverändert kopiert)
astro.config.mjs  ← Framework-Konfiguration

Schritt 2: Syntax von Astro-Komponenten

.astro-Dateien haben oben einen Code-Bereich (nur serverseitig) und darunter eine Vorlage:

---
// src/components/Card.astro
// Dieser Block läuft NUR auf dem Server – niemals im Browser
interface Props {
  title: string;
  href: string;
  description: string;
}

const { title, href, description } = Astro.props;
---

<article class="card">
  <h2><a href={href}>{title}</a></h2>
  <p>{description}</p>
</article>

<style>
  /* Wird automatisch auf diese Komponente beschränkt */
  .card { border: 1px solid #eee; padding: 1rem; }
</style>

Schritt 3: Dateibasierte Seiten und Routing

src/pages/index.astro          → /
src/pages/about.astro          → /about
src/pages/blog/[slug].astro    → /blog/:slug (dynamisch)
src/pages/blog/[...path].astro → /blog/* (Auffangpfad)

Dynamische Route mit getStaticPaths:

---
// src/pages/blog/[slug].astro
export async function getStaticPaths() {
  const posts = await getCollection('blog');
  return posts.map(post => ({
    params: { slug: post.slug },
    props: { post },
  }));
}

const { post } = Astro.props;
const { Content } = await post.render();
---

<h1>{post.data.title}</h1>
<Content />

Schritt 4: Inhaltskollektionen

Inhaltskollektionen bieten typsicheren Zugriff auf Markdown- und MDX-Dateien:

// src/content/config.ts
import { z, defineCollection } from 'astro:content';

const blog = defineCollection({
  type: 'content',
  schema: z.object({
    title: z.string(),
    date: z.coerce.date(),
    tags: z.array(z.string()).default([]),
    draft: z.boolean().default(false),
  }),
});

export const collections = { blog };
---
// src/pages/blog/index.astro
import { getCollection } from 'astro:content';

const posts = (await getCollection('blog'))
  .filter(p => !p.data.draft)
  .sort((a, b) => b.data.date.valueOf() - a.data.date.valueOf());
---

<ul>
  {posts.map(post => (
    <li>
      <a href={`/blog/${post.slug}`}>{post.data.title}</a>
      <time>{post.data.date.toLocaleDateString()}</time>
    </li>
  ))}
</ul>

Schritt 5: Inseln – Selektive Hydratation

Standardmäßig rendern UI-Framework-Komponenten zu statischem HTML ohne JS. Verwende client:-Direktiven zur Hydratation:

---
import Counter from '../components/Counter.tsx';  // React-Komponente
import VideoPlayer from '../components/VideoPlayer.svelte';
---

<!-- Statisches HTML – kein JavaScript wird an den Browser gesendet -->
<Counter initialCount={0} />

<!-- Sofort beim Seitenladen hydratisieren -->
<Counter initialCount={0} client:load />

<!-- Hydratisieren, wenn die Komponente in den sichtbaren Bereich gelangt -->
<VideoPlayer src="/demo.mp4" client:visible />

<!-- Nur hydratisieren, wenn der Browser im Leerlauf ist -->
<Analytics client:idle />

<!-- Nur bei einer bestimmten Media Query hydratisieren -->
<MobileMenu client:media="(max-width: 768px)" />

Schritt 6: Layouts

---
// src/layouts/BaseLayout.astro
interface Props {
  title: string;
  description?: string;
}
const { title, description = 'Meine Astro-Seite' } = Astro.props;
---

<html lang="de">
  <head>
    <meta charset="utf-8" />
    <title>{title}</title>
    <meta name="description" content={description} />
  </head>
  <body>
    <nav>...</nav>
    <main>
      <slot />  <!-- Seiteninhalt wird hier gerendert -->
    </main>
    <footer>...</footer>
  </body>
</html>
---
// src/pages/about.astro
import BaseLayout from '../layouts/BaseLayout.astro';
---

<BaseLayout title="Über uns">
  <h1>Über uns</h1>
  <p>Willkommen bei unserem Unternehmen...</p>
</BaseLayout>

Schritt 7: SSR-Modus (On-Demand Rendering)

Aktiviere SSR für dynamische Seiten durch Setzen eines Adapters:

// astro.config.mjs
import { defineConfig } from 'astro/config';
import vercel from '@astrojs/vercel/serverless';

export default defineConfig({
  output: 'hybrid',  // 'static' | 'server' | 'hybrid'
  adapter: vercel(),
});

Optiere einzelne Seiten für SSR mit export const prerender = false.

Beispiele

Beispiel 1: Blog mit RSS-Feed

// src/pages/rss.xml.ts
import rss from '@astrojs/rss';
import { getCollection } from 'astro:content';

export async function GET(context) {
  const posts = await getCollection('blog');
  return rss({
    title: 'Mein Blog',
    description: 'Neueste Beiträge',
    site: context.site,
    items: posts.map(post => ({
      title: post.data.title,
      pubDate: post.data.date,
      link: `/blog/${post.slug}/`,
    })),
  });
}

Beispiel 2: API-Endpunkt (SSR)

// src/pages/api/subscribe.ts
import type { APIRoute } from 'astro';

export const POST: APIRoute = async ({ request }) => {
  const { email } = await request.json();

  if (!email) {
    return new Response(JSON.stringify({ error: 'E-Mail erforderlich' }), {
      status: 400,
      headers: { 'Content-Type': 'application/json' },
    });
  }

  await addToNewsletter(email);
  return new Response(JSON.stringify({ success: true }), { status: 200 });
};

Beispiel 3: React-Komponente als Insel

// src/components/SearchBox.tsx
import { useState } from 'react';

export default function SearchBox() {
  const [query, setQuery] = useState('');
  const [results, setResults] = useState([]);

  async function search(e: React.FormEvent) {
    e.preventDefault();
    const data = await fetch(`/api/search?q=${query}`).then(r => r.json());
    setResults(data);
  }

  return (
    <form onSubmit={search}>
      <input value={query} onChange={e => setQuery(e.target.value)} />
      <button type="submit">Suchen</button>
      <ul>{results.map(r => <li key={r.id}>{r.title}</li>)}</ul>
    </form>
  );
}
---
import SearchBox from '../components/SearchBox.tsx';
---
<!-- Sofort hydratisiert – diese Insel ist interaktiv -->
<SearchBox client:load />

Best Practices

  • ✅ Behalte die meisten Komponenten als statische .astro-Dateien – hydratisiere nur, was interaktiv sein muss
  • ✅ Verwende Inhaltskollektionen für alle Markdown/MDX-Inhalte – du erhältst Typsicherheit und automatische Validierung
  • ✅ Bevorzuge client:visible gegenüber client:load für Komponenten unterhalb des Bildschirmrands, um anfängliches JS zu reduzieren
  • ✅ Verwende import.meta.env für Umgebungsvariablen – stelle öffentlichen Variablen PUBLIC_ voran
  • ✅ Füge <ViewTransitions /> von astro:transitions hinzu, für flüssige Seitennavigation ohne vollständige SPA
  • ❌ Verwende nicht client:load auf jeder Komponente – das hebt den Performance-Vorteil von Astro auf
  • ❌ Gib keine Geheimnisse im Frontmatter von .astro an, das in clientseitigen Vorlagen verwendet wird
  • ❌ Überspringe nicht getStaticPaths für dynamische Routen im statischen Modus – Builds werden fehlschlagen

Sicherheitshinweise

  • Der Code im Frontmatter von .astro-Dateien läuft nur serverseitig und wird niemals dem Browser ausgesetzt.
  • Verwende import.meta.env.PUBLIC_* nur für nicht sensible Werte. Private Umgebungsvariablen (ohne PUBLIC_-Präfix) werden niemals an den Client gesendet.
  • Validiere im SSR-Modus alle Eingaben von Astro.request vor Datenbankabfragen oder API-Aufrufen.
  • Bereinige alle benutzergenerierten Inhalte vor der Wiedergabe mit set:html – dies umgeht die automatische Escape-Funktion.

Häufige Fallstricke

  • Problem: JavaScript einer React/Vue-Komponente läuft nicht im Browser Lösung: Füge eine client:-Direktive hinzu (client:load, client:visible, usw.) – ohne diese werden Komponenten nur als statisches HTML gerendert.

  • Problem: getStaticPaths-Daten sind nach Inhaltsaktualisierungen während der Entwicklung veraltet Lösung: Der Entwicklungsserver von Astro überwacht Inhaltsdateien – starte ihn neu, wenn Änderungen an content/config.ts nicht berücksichtigt werden.

  • Problem: Der Astro.props-Typ ist any – keine Autovervollständigung Lösung: Definiere ein Props-Interface oder einen -Typ im Frontmatter, und Astro leitet diesen automatisch ab.

  • Problem: CSS aus einer .astro-Komponente beeinflusst andere Komponenten Lösung: Styles in <style>-Tags von .astro werden automatisch beschränkt. Verwende :global() nur, wenn du absichtlich untergeordnete Elemente ansprichst.

Verwandte Fähigkeiten

  • @sveltekit – Wenn du ein Full-Stack-Framework mit reaktiver UI benötigst (im Gegensatz zu Astros Inhaltsfokus)
  • @nextjs-app-router-patterns – Wenn du ein React-zentriertes Full-Stack-Framework benötigst
  • @tailwind-patterns – Gestaltung von Astro-Seiten mit Tailwind CSS
  • @progressive-web-app – Hinzufügen von PWA-Funktionen zu einer Astro-Seite

Einschränkungen

  • Verwende diesen Skill nur, wenn die Aufgabe eindeutig mit dem oben beschriebenen Umfang übereinstimmt.
  • Betrachte die Ausgabe nicht als Ersatz für umgebungsspezifische Validierung, Tests oder fachkundige Überprüfung.
  • Halte inne und bitte um Klärung, wenn erforderliche Eingaben, Berechtigungen, Sicherheitsgrenzen oder Erfolgskriterien fehlen.

Individual skills in this repo

This repo contains 20 individual skills — each has its own dedicated page.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches 007: Security audit, hardening, threat modeling (STRIDE/PASTA), Red/Blue Team, OWASP checks, code review, incident response, and infrastructure security for any project.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Agentfolio: Skill for discovering and researching autonomous AI agents, tools, and ecosystems using the AgentFolio directory.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Animejs Animation: Advanced JavaScript animation library skill for creating complex, high-performance web animations.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Astropy: Astropy is the core Python package for astronomy, providing essential functionality for astronomical research and data analysis.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Emotional ARC Designer: One sentence - what this skill does and when to invoke it

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Fixing Motion Performance: Audit and fix animation performance issues including layout thrashing, compositor properties, scroll-linked motion, and blur effects.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches I18n Localization: Internationalization and localization patterns.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Interactive Portfolio: Expert in building portfolios that actually land jobs and clients - not just showing work, but creating memorable experiences.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches JQ: Expert jq usage for JSON querying, filtering, transformation, and pipeline integration.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Landing Page Generator: Generates high-converting Next.js/React landing pages with Tailwind CSS.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches LEX: Centralized ''Truth Engine'' for cross-jurisdictional legal context (US, EU, CA) and contract scaffolding.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Magic Animator: AI-powered animation tool for creating motion in logos, UI, icons, and social media assets.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Makepad Animation: CRITICAL: Use for Makepad animation system.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Nextjs APP Router Patterns: Comprehensive patterns for Next.js 14+ App Router architecture, Server Components, and modern full-stack React development.

Anhvu1107/all-agent-skill

ALWAYS use this when the user mentions Nextjs Best Practices, asks to build, debug, review, document, automate, test, configure, migrate, or make decisions in this domain, or the task clearly depends on Nextjs Best Practices; scope: Next.js App Router principles. Apply the bundled workflow, references, scripts, Senior Master standard, and Codex strict review gate before final output.

Anhvu1107/all-agent-skill

description: ALWAYS use this when the work is specifically about modern Next.js or React architecture, data flow, rendering strategy, routing, or performance-sensitive frontend behavior.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches Nextjs Supabase Auth: Expert integration of Supabase Auth with Next.js App Router

Anhvu1107/all-agent-skill

ALWAYS use this when the task involves reading, extracting, splitting, merging, rotating, creating, validating, OCR-ing, form-filling, or otherwise producing or modifying PDF files.

Anhvu1107/all-agent-skill

ALWAYS use this when the request matches React Nextjs Development: React and Next.js 14+ application development with App Router, Server Components, TypeScript, Tailwind CSS, and modern frontend patterns.

Anhvu1107/all-agent-skill

ALWAYS use this when working with Remotion code, video compositions, rendering logic, timing, media assets, or React-based motion workflows.

Verwandte Skills