Skip to content
Back to search

mad-agents-skills

Collection of agent skills for AI assistants working with Dart and Flutter projects

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/madteacher--mad-agents-skills/badge.svg)](/listings/madteacher--mad-agents-skills)

HTML

<a href="/listings/madteacher--mad-agents-skills"><img src="/api/listings/madteacher--mad-agents-skills/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 735 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # MAD Agents Skills
  2. [Russian version](README.ru.md)
  3. A collection of agent skills for AI assistants working with Dart and Flutter projects, implemented in the [**Agent Skills**](https://agentskills.io/home) format — an open standard for extending AI agents.
  4. Each skill provides **structured knowledge** based on official documentation, ready-to-use code examples, and detailed reference materials that AI agents can leverage.
  5. ## Contents 📋
  6. - [Overview](#overview)
  7. - [Skills](#skills)
  8. - [AGENTS.md Generator](#agents-md-generator)
  9. - [Dart Drift](#dart-drift)
  10. - [Flutter Adaptive UI](#flutter-adaptive-ui)
  11. - [Flutter Animations](#flutter-animations)
  12. - [Flutter Architecture](#flutter-architecture)
  13. - [Flutter Drift](#flutter-drift)
  14. - [Flutter Internationalization](#flutter-internationalization)
  15. - [Flutter Navigation](#flutter-navigation)
  16. - [Flutter Networking](#flutter-networking)
  17. - [Flutter Testing](#flutter-testing)
  18. - [Flutter Backend-driven UI with Duit](#flutter-backend-driven-ui-with-duit)
  19. - [File structure](#file-structure)
  20. - [How to use](#how-to-use)
  21. - [Skills application matrix](#skills-application-matrix)
  22. - [License](#license)
  23. - [Contributing](#contributing)
  24. - [Additional resources](#additional-resources)
  25. ## Overview 🎯
  26. This repository contains a set of specialized skills for Dart and Flutter development, organized according to the open [**Agent Skills**](https://agentskills.io/home) standard.
  27. ### What are Agent Skills?
  28. Agent Skills are an open format for providing AI agents with new capabilities and expertise. They are structured folders with instructions, scripts, and resources that agents can discover and use to complete tasks more accurately and efficiently.
  29. **Created by:** Anthropic
  30. **Status:** Open standard
  31. **Supported by:** Leading AI development tools
  32. ### Skill composition
  33. Each skill includes:
  34. - **SKILL.md** — skill description with metadata and usage conditions
  35. - **Reference documentation** — detailed guides in `references/`
  36. - **Code examples** — ready-to-use templates and examples in `assets/`
  37. - **Best practices** — recommendations and guidelines
  38. - **Scripts** (optional) — helper utilities in `scripts/`
  39. ### What Agent Skills enable
  40. ✨ **Domain expertise** — specialized knowledge in specific areas
  41. 🚀 **New capabilities** — new abilities for agents
  42. 🔄 **Repeatable workflows** — standardized, repeatable workflows
  43. 🔗 **Interoperability** — reuse across different AI tools
  44. ## Skills 🛠️
  45. ### AGENTS.md Generator
  46. **Directory:** `agents-md-generator/`
  47. **Description:** Create or update minimal AGENTS.md files in the repository root and nested module directories using progressive disclosure. Works across heterogeneous projects without assuming any fixed agent folder structure.
  48. **When to use:**
  49. - AGENTS.md is missing, bloated, contradictory, or outdated
  50. - A new package/service/module appears
  51. - Repository structure changes (monorepo growth or split)
  52. - Teams want consistent agent context across diverse stacks
  53. **Key capabilities:**
  54. - Discover repository shape (git root, language/tool markers)
  55. - Detect module boundaries (build manifests, deployable units)
  56. - Generate root AGENTS.md (≤60 lines): purpose, toolchain, commands, docs links
  57. - Generate nested AGENTS.md (≤40 lines): module purpose, local commands
  58. - Progressive disclosure: keep AGENTS.md concise, link to docs/skills
  59. - Adaptive skill referencing (local or external)
  60. **Output:**
  61. - `<repo_root>/AGENTS.md`
  62. - `<module_dir>/AGENTS.md` (for independent packages/services)
  63. **References:**
  64. - `AGENTS_TEMPLATE_ROOT.md` — Root AGENTS.md template
  65. - `AGENTS_TEMPLATE_MODULE.md` — Nested module template
  66. ---
  67. ### Dart Drift
  68. **Directory:** `dart-drift/`
  69. **Description:** An operational workflow for adding, fixing, migrating, and validating Drift persistence in Dart CLI, server-side, and non-Flutter desktop apps.
  70. **When to use:**
  71. - Adding local SQLite storage with `package:drift/native.dart`
  72. - Connecting server-side apps to PostgreSQL with `drift_postgres`
  73. - Writing type-safe tables, queries, writes, and reactive streams
  74. - Implementing and validating database schema migrations
  75. - Fixing `build_runner`, `drift_dev`, or generated-code failures
  76. **Key capabilities:**
  77. - Setup with `sqlite3`, `drift_postgres`, and `package:postgres`
  78. - Defining tables and constraints
  79. - SELECT, WHERE, JOIN, aggregations
  80. - INSERT, UPDATE, DELETE, transactions
  81. - Reactive stream queries
  82. - Database schema migrations and generated migration tests
  83. - Deterministic smoke validation via `scripts/verify-examples.sh`
  84. **References:**
  85. - `setup.md` — SQLite & PostgreSQL setup
  86. - `postgres.md` — PostgreSQL-specific features
  87. - `tables.md` — Table definitions
  88. - `queries.md` — Database queries
  89. - `writes.md` — Write operations
  90. - `streams.md` — Reactive streams
  91. - `migrations.md` — Schema migrations
  92. ---
  93. ### Flutter Adaptive UI
  94. **Directory:** `flutter-adaptive-ui/`
  95. **Description:** Building adaptive and responsive Flutter UIs that work great across platforms and screen sizes.
  96. **When to use:**
  97. - Building apps for multiple platforms (mobile, tablet, desktop, web)
  98. - Adapting layouts for different screen sizes
  99. - Supporting different input devices (touch, mouse, keyboard)
  100. - Implementing responsive navigation patterns
  101. - Optimizing for large screens and foldables
  102. - Using Capability and Policy patterns for platform-specific behavior
  103. **Key concepts:**
  104. - **3-step approach:** Abstract → Measure → Branch
  105. - **Breakpoints:** Compact (<600), Medium (600-840), Expanded (≥840)
  106. - **Layout rule:** Constraints go down. Sizes go up. Parent sets position.
  107. - **Capability/Policy pattern** for platform-specific behavior
  108. **References:**
  109. - `layout-constraints.md` — Constraints system with 29 examples
  110. - `layout-basics.md` — Core layout widgets
  111. - `layout-common-widgets.md` — Container, GridView, ListView, Stack
  112. - `adaptive-workflow.md` — The 3-step approach in detail
  113. - `adaptive-best-practices.md` — Design best practices
  114. - `adaptive-capabilities.md` — Capability/Policy pattern
  115. **Examples:**
  116. - `responsive_navigation.dart` — Switching NavigationBar ↔ NavigationRail
  117. - `capability_policy_example.dart` — Capability/Policy class examples
  118. ---
  119. ### Flutter Animations
  120. **Directory:** `flutter-animations/`
  121. **Description:** A comprehensive guide to implementing animations in Flutter.
  122. **When to use:**
  123. - Adding motion and visual effects to your app
  124. - Implementing implicit animations (simple transitions)
  125. - Building explicit animations (full control)
  126. - Implementing hero animations (shared element transitions)
  127. - Creating staggered animations (sequential/overlapping)
  128. - Using physics-based animations
  129. **Animation types:**
  130. **Implicit Animations** — for simple cases:
  131. - AnimatedContainer, AnimatedOpacity
  132. - TweenAnimationBuilder
  133. - Animations are triggered by state changes
  134. **Explicit Animations** — for full control:
  135. - AnimationController, Tween, CurvedAnimation
  136. - AnimatedWidget, AnimatedBuilder
  137. - Monitoring animation state
  138. - Multiple simultaneous animations
  139. **Hero Animations** — shared element transitions:
  140. - Standard hero transitions
  141. - Radial hero animations
  142. - Navigation between screens
  143. **Staggered Animations** — sequential effects:
  144. - Interval-based timing
  145. - Ripple effects
  146. - Menus with sequential appearance
  147. **Physics-Based** — natural motion:
  148. - Spring simulations
  149. - Fling animations
  150. - Gravity-based animations
  151. **References:**
  152. - `implicit.md` — Implicit animations
  153. - `explicit.md` — Explicit animations with AnimationController
  154. - `hero.md` — Hero transitions
  155. - `staggered.md` — Staggered patterns
  156. - `physics.md` — Physics-based animations
  157. - `curves.md` — Curves reference
  158. **Templates:**
  159. - `implicit_animation.dart`
  160. - `explicit_animation.dart`
  161. - `hero_transition.dart`
  162. - `staggered_animation.dart`
  163. ---
  164. ### Flutter Architecture
  165. **Directory:** `flutter-architecture/`
  166. **Description:** A comprehensive guide to Flutter app architecture using the MVVM pattern and feature-first organization.
  167. **When to use:**
  168. - Designing or refactoring a Flutter app architecture
  169. - Choosing between feature-first and layer-first project structures
  170. - Implementing MVVM in Flutter
  171. - Building a scalable structure for teams
  172. - Adding new features to an existing architecture
  173. - Applying best practices and design patterns
  174. **Project organization:**
  175. **Feature-First (recommended for teams):**
  176. - Organized by business capabilities
  177. - Medium and large apps (10+ features)
  178. - Team development (2+ developers)
  179. - Self-contained feature modules
  180. **Layer-First (traditional):**
  181. - Organized by architectural layers
  182. - Small and medium apps
  183. - Solo developers or small teams
  184. - Simple business logic
  185. **Architectural layers:**
  186. - **UI Layer:** Views (widgets) and ViewModels (UI logic)
  187. - **Data Layer:** Repositories (SSOT) and Services (data sources)
  188. - **Domain Layer:** Use cases for complex business logic (optional)
  189. **Design patterns:**
  190. - Command Pattern — action encapsulation
  191. - Result Type — type-safe error handling
  192. - Repository Pattern — abstraction over data sources
  193. - Offline-First — optimistic UI updates
  194. **References:**
  195. - `concepts.md` — Core architecture principles
  196. - `feature-first.md` — Feature-first organization
  197. - `mvvm.md` — MVVM implementation
  198. - `layers.md` — Layers and their interactions
  199. - `design-patterns.md` — Common patterns
  200. **Examples:**
  201. - `command.dart` — Command pattern template
  202. - `result.dart` — Result type for error handling
  203. - `examples/` — Architecture usage examples
  204. ---
  205. ### Flutter Drift
  206. **Directory:** `flutter-drift/`
  207. **Description:** A complete guide to using the drift library for local storage in Flutter apps.
  208. **When to use:**
  209. - Building Flutter apps with a local SQLite database
  210. - Needing type-safe queries
  211. - Implementing reactive stream queries
  212. - Database schema migrations
  213. - Efficient CRUD operations
  214. - Cross-platform support (mobile, web, desktop)
  215. **Key capabilities:**
  216. - Setup with the `drift_flutter` package
  217. - StreamBuilder integration for reactive UI
  218. - Provider/Riverpod patterns
  219. - Platform-specific setup (mobile, web)
  220. - In-memory database for testing
  221. - Versioned schema migrations
  222. **References:**
  223. - `setup.md` — Flutter-specific setup
  224. - `tables.md` — Table definitions
  225. - `queries.md` — SELECT queries
  226. - `writes.md` — INSERT, UPDATE, DELETE
  227. - `streams.md` — Reactive streams
  228. - `migrations.md` — Database migrations
  229. - `flutter-ui.md` — Flutter UI integration
  230. ---
  231. ### Flutter Internationalization
  232. **Directory:** `flutter-internationalization/`
  233. **Description:** A complete guide to internationalizing Flutter apps using gen-l10n and intl.
  234. **When to use:**
  235. - Adding localization support to a Flutter app
  236. - Translating UI text into multiple languages
  237. - Formatting numbers and dates for different locales
  238. - Configuring multilingual support for Material/Cupertino
  239. - Implementing RTL (right-to-left) languages
  240. - Managing ARB files and translations
  241. **Approaches:**
  242. **gen-l10n (recommended):**
  243. - Modern, automated approach
  244. - ARB files + code generation
  245. - Best for new projects and teams
  246. **intl package:**
  247. - Manual control
  248. - Code-based translations
  249. - For simple or legacy projects
  250. **Custom/Manual:**
  251. - Maximum flexibility
  252. - Map-based lookup
  253. - Very simple apps
  254. **Message types:**
  255. - Simple messages
  256. - With placeholders (parameters)
  257. - Plural messages
  258. - Select messages
  259. - Number and date formatting
  260. **References:**
  261. - `l10n-config.md` — l10n.yaml configuration
  262. - `arb-format.md` — ARB file format
  263. - `number-date-formats.md` — Number and date formatting
  264. **Examples:**
  265. - `app_en.arb` — Example ARB file
  266. - `l10n.yaml` — Configuration file
  267. ---
  268. ### Flutter Navigation
  269. **Directory:** `flutter-navigation/`
  270. **Description:** A comprehensive guide to navigation and routing in Flutter, including Navigator API, go_router, deep linking, and web navigation.
  271. **When to use:**
  272. - Implementing screen-to-screen navigation
  273. - Configuring routing
  274. - Setting up deep links (iOS, Android, Web)
  275. - Handling browser history
  276. - Managing navigation state
  277. - Passing and returning data between screens
  278. **Choosing an approach:**
  279. **Navigator API (imperative):**
  280. - Simple apps without deep linking
  281. - Basic navigation stacks
  282. - Rapid prototyping
  283. - Moving from single-screen → multi-screen
  284. **go_router (declarative, recommended):**
  285. - Apps with deep linking
  286. - Web apps with browser history
  287. - Complex navigation patterns
  288. - URL-based navigation
  289. - Production apps
  290. **Avoid Named Routes:**
  291. - Not recommended by the Flutter team
  292. - Limitations in deep-link customization
  293. - No support for the browser forward button
  294. **Common tasks:**
  295. - Passing data between screens
  296. - Returning data from screens
  297. - Deep linking setup (Android, iOS, Web)
  298. - Web URL strategy (hash vs path)
  299. - Route guards (authentication)
  300. - Nested routes
  301. - Error handling (404)
  302. **References:**
  303. - `navigation-patterns.md` — Approach comparison
  304. - `go_router-guide.md` — Detailed go_router guide
  305. - `deep-linking.md` — Deep link setup
  306. - `web-navigation.md` — Web-specific navigation
  307. **Examples:**
  308. - `navigator_basic.dart` — Basic Navigator
  309. - `go_router_basic.dart` — Basic go_router
  310. - `passing_data.dart` — Passing data
  311. - `returning_data.dart` — Returning data
  312. ---
  313. ### Flutter Networking
  314. **Directory:** `flutter-networking/`
  315. **Description:** Implement, debug, review, and harden Flutter networking, including HTTP/REST APIs, WebSocket flows, authentication, error handling, and performance.
  316. **When to use:**
  317. - Implementing HTTP requests (GET, POST, PUT, DELETE)
  318. - WebSocket connections for real-time communication
  319. - Authenticated requests with headers and tokens
  320. - Background parsing with isolates
  321. - REST API integration
  322. - Debugging or reviewing existing networking code
  323. - Adapting to existing `http`, Dio, Retrofit, Chopper, or custom clients
  324. - Handling network errors
  325. - Optimizing networking performance
  326. **HTTP methods:**
  327. - **GET** — fetch data
  328. - **POST** — create resources
  329. - **PUT** — update resources
  330. - **DELETE** — delete resources
  331. **WebSocket:**
  332. - Connections with `web_socket_channel`
  333. - Stream-based messaging
  334. - Real-time communication
  335. **Authentication:**
  336. - Bearer Token
  337. - Basic Auth
  338. - API Key
  339. - Custom headers
  340. **Error handling:**
  341. - HTTP status codes
  342. - Network exceptions
  343. - Timeout handling
  344. - Retry logic with exponential backoff
  345. **Performance:**
  346. - Background parsing with `compute()`
  347. - Caching strategies
  348. - Connection pooling
  349. - Request throttling
  350. **Architecture patterns:**
  351. - Service Layer (HTTP endpoints)
  352. - Repository Layer (caching, aggregation)
  353. - ViewModel Layer (UI transformation)
  354. **References:**
  355. - `http-basics.md` — HTTP CRUD operations
  356. - `websockets.md` — WebSocket implementation
  357. - `authentication.md` — Authentication strategies
  358. - `error-handling.md` — Error handling patterns
  359. - `performance.md` — Optimization
  360. **Examples:**
  361. - `fetch_example.dart` — GET request with FutureBuilder
  362. - `post_example.dart` — POST request
  363. - `websocket_example.dart` — WebSocket client
  364. - `auth_example.dart` — Authenticated request
  365. - `background_parsing.dart` — `compute()` for JSON
  366. **Templates:**
  367. - `http_service.dart` — HTTP service template
  368. - `repository_template.dart` — Repository pattern template
  369. ---
  370. ### Flutter Testing
  371. **Directory:** `flutter-testing/`
  372. **Description:** A comprehensive guide to testing Flutter apps: unit, widget, and integration tests.
  373. **When to use:**
  374. - Writing unit tests for functions/methods/classes
  375. - Creating widget tests to validate UI components
  376. - Building integration tests for end-to-end coverage
  377. - Mocking dependencies and plugin interactions
  378. - Debugging common testing issues
  379. - Testing Flutter plugins with native code
  380. - Running tests in different build modes
  381. **Test types:**
  382. **Unit Tests:**
  383. - Testing individual functions/classes
  384. - Mocking external dependencies
  385. - Avoiding disk I/O and UI rendering
  386. - Fast execution, high maintainability
  387. **Widget Tests:**
  388. - Testing UI widgets
  389. - Verifying user interactions
  390. - Testing different orientations
  391. - Validating state changes
  392. **Integration Tests:**
  393. - Testing full user flows
  394. - Covering multiple screens/pages
  395. - Testing navigation
  396. - Performance profiling
  397. **Trade-offs:**
  398. | | Unit | Widget | Integration |
  399. |------------------|--------|--------|-------------|
  400. | Confidence | Low | Higher | Highest |
  401. | Maintenance cost | Low | Higher | Highest |
  402. | Execution speed | Quick | Quick | Slow |
  403. **Working with plugins:**
  404. - Mocking platform channels
  405. - Testing app code that depends on plugins
  406. - Testing plugins themselves
  407. - Native code testing
  408. **Common issues:**
  409. - RenderFlex overflow
  410. - Unbounded height/width
  411. - setState during build
  412. - Plugin crashes in tests
  413. **Build Modes:**
  414. - **Debug** — development with hot reload
  415. - **Profile** — performance analysis
  416. - **Release** — deployment (assertions disabled)
  417. **Best practices:**
  418. - Test Pyramid (more unit/widget, fewer integration)
  419. - Descriptive test names
  420. - Arrange–Act–Assert structure
  421. - Test independence
  422. - Mock external dependencies
  423. - CI automation
  424. **References:**
  425. - `unit-testing.md` — Unit tests and mocking
  426. - `widget-testing.md` — Widget finding and interactions
  427. - `integration-testing.md` — End-to-end testing
  428. - `mocking.md` — Dependency mocking
  429. - `common-errors.md` — Fixes for common issues
  430. - `plugin-testing.md` — Plugin testing
  431. ---
  432. ### Flutter Backend-driven UI with Duit
  433. **Directory:** `flutter-duit-bdui/`
  434. **Description:** An agent workflow for integrating, fixing, reviewing, and validating the BDUI framework [flutter_duit](https://pub.dev/packages/flutter_duit) in Flutter apps.
  435. **When to use:**
  436. - Integrating flutter_duit into a project
  437. - Creating and registering custom widgets
  438. - Registering components
  439. - Overriding core framework behavior by implementing capabilities
  440. - Needing reference information about the framework’s public API
  441. **References:**
  442. - [capabilities.md](./flutter-duit-bdui/references/capabilities.md) — Notes on capability-based design and overriding core framework parts.
  443. - [troubleshooting.md](./flutter-duit-bdui/references/troubleshooting.md) — Notes on common framework integration issues.
  444. - [environment_vars.md](./flutter-duit-bdui/references/environment_vars.md) — Notes on available environment variables and how to use them.
  445. - [public_api.md](./flutter-duit-bdui/references/public_api.md) — Notes on the driver’s public API.
  446. - <https://duit.pro/docs/en> — Official documentation website
  447. ## File structure 📁
  448. Each skill is organized as follows:
  449. ```
  450. skill-name/
  451. ├── SKILL.md # Main skill description
  452. ├── references/ # Reference documentation
  453. │ ├── topic1.md
  454. │ ├── topic2.md
  455. │ └── ...
  456. ├── assets/ # Code examples and templates
  457. │ ├── examples/
  458. │ ├── templates/
  459. │ └── ...
  460. └── scripts/ # Helper scripts (optional)
  461. ```
  462. ## How to use 🚀
  463. This repository follows the open [Agent Skills](https://agentskills.io/home) format — a standard for giving AI agents new capabilities and expertise. Agent Skills are folders with instructions, scripts, and resources that agents can discover and use to complete tasks more accurately and efficiently.
  464. ### Compatibility
  465. Skills from this repository can be used by any AI assistants that support the Agent Skills format, including:
  466. - Anthropic Claude (with Agent Skills support)
  467. - Cursor IDE
  468. - Other compatible development tools
  469. ### Benefits of Agent Skills
  470. **For skill authors:**
  471. - Create a skill once and use it across many AI tools
  472. - Version control with Git
  473. - Portability across projects and teams
  474. **For teams and organizations:**
  475. - Capturing organizational knowledge in a structured format
  476. - Standardizing development approaches
  477. - Reusing best practices
  478. **For AI agents:**
  479. - An extendable knowledge base without retraining
  480. - Context-dependent expertise
  481. - Repeatable workflows
  482. ## Skills application matrix 📊
  483. | Task | Skill | When to use |
  484. |--------|-------|-------------------|
  485. | AGENTS.md / repository context | agents-md-generator | Creating/updating AGENTS.md, monorepo structure |
  486. | Local DB (Dart) | dart-drift | CLI, server-side, non-Flutter desktop |
  487. | Local DB (Flutter) | flutter-drift | Flutter apps, mobile/web/desktop |
  488. | Adaptive UI | flutter-adaptive-ui | Multi-platform, responsive layouts |
  489. | Animations | flutter-animations | Motion effects, transitions |
  490. | Project architecture | flutter-architecture | MVVM, feature-first, scalable structure |
  491. | Internationalization | flutter-internationalization | Localization, translations, i18n |
  492. | Navigation | flutter-navigation | Routing, deep linking, screen transitions |
  493. | Backend-driven UI (BDUI) | flutter-duit-bdui | DUIT, server-driven UI, backend-driven screens |
  494. | Networking | flutter-networking | HTTP, WebSocket, REST API |
  495. | Testing | flutter-testing | Unit, widget, integration tests |
  496. ## License 📝
  497. This project is licensed under the MIT License — see [LICENSE](LICENSE) for details.
  498. ## Contributing 🤝
  499. Contributions are welcome! Please:
  500. - Follow the [Agent Skills specification](https://agentskills.io/specification)
  501. - Follow the existing skill structure in the repository
  502. - Add practical examples to `assets/`
  503. - Document usage conditions in `SKILL.md`
  504. - Include best practices and reference materials in `references/`
  505. - Use metadata in the `SKILL.md` frontmatter
  506. ## Additional resources 📚
  507. ### Agent Skills
  508. - [Agent Skills — Official website](https://agentskills.io/home)
  509. - [Agent Skills format specification](https://agentskills.io/specification)
  510. - [Agent Skills integration](https://agentskills.io/integrate-skills)
  511. - [Agent Skills on GitHub](https://github.com/agentskills/agentskills)
  512. ---
  513. **Version:** 2.0
  514. **Last updated:** May 2026

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.