native-data-fetching

Implement and debug network requests with fetch, Axios, React Query, or SWR.

Updated Jan 19, 2026
One-click install
npx skills add https://github.com/dcoon/kbms --skill native-data-fetching-dcoon
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: native-data-fetching
Source: https://github.com/dcoon/kbms/tree/main/.gemini/skills/native-data-fetching
Command: npx skills add https://github.com/dcoon/kbms --skill native-data-fetching-dcoon

SYSTEM DOCUMENTATION & REQUIREMENTS

What problem does it solve?

This skill guides implementing and debugging network requests, API calls, and data fetching with best practices to help developers build reliable, scalable network code across mobile and web apps.

Core Features & Use Cases

  • Unified fetch wrappers for consistent error handling, response parsing, and retry strategies.
  • Data fetching with caching using React Query, SWR, or similar tools to reduce redundant requests and improve UX.
  • Offline support and resilience through offline queues and synchronization strategies for intermittent connectivity.
  • Real-world scenario: build a robust API client that gracefully handles network failures, token management, and multi-environment configs.

Quick Start

Implement a robust fetch wrapper with error handling, caching, and offline support for your React Native app.

Frequently Asked Questions about native-data-fetching

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I implement robust error handling and retry strategies for API calls?

Robust error handling for API calls requires unified fetch wrappers that standardize response parsing and execute consistent retry strategies. This approach ensures reliable network code by catching failures centrally and applying deterministic retry logic across web and mobile apps.

What is the best way to manage caching and reduce redundant network requests?

Caching with React Query or SWR is the best way to manage data fetching and reduce redundant network requests. These tools cache API responses automatically, minimizing unnecessary traffic and improving user experience by serving stale data while revalidating in the background.

How do I add offline support and synchronization for intermittent connectivity?

Offline support for intermittent connectivity is implemented through offline queues and synchronization strategies. This mechanism stores failed API calls locally during network outages and automatically retries them once connection is restored, ensuring data fetching resilience.

Does this approach work with both Axios and native fetch for environment configuration?

Yes, this approach works with Axios, native fetch, React Query, and SWR for environment configuration. It applies unified wrappers to manage tokens and multi-environment API configs, ensuring deterministic data flows across different HTTP clients and platforms.

Why does my token management fail across multiple environments?

Token management fails across multiple environments when API configuration is hardcoded instead of environment-based. Implementing clear environment-based API configuration with unified fetch wrappers resolves this by dynamically routing authentication tokens to the correct endpoints.