Skip to main content
skill CX Codex

network-accessibility-analysis — Claude Code skill guide

Replaces straight-line buffers with true network travel costs across walking, transit, and driving modes. Builds isochrones and origin-destination matrices.

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add muend/geoai-skills --skill network-accessibility-analysis -a claude-code
Open on GitHub

What network-accessibility-analysis does

This skill guides the agent to evaluate real travel impedance along transport networks instead of relying on straight-line Euclidean approximations. It selects libraries based on problem scale: OSMnx with NetworkX for local urban studies, and pandana or r5py when processing many-to-many origin-destination pairs exceeding 10⁴×10⁴.

The instructions enforce strict graph hygiene. That means matching network_type to the travel mode, projecting coordinates into a metric CRS, and keeping only the largest strongly connected component. Running pedestrian routing on a driving network misses alleys and stairs, while unchecked snapping to distant road nodes silently distorts travel times near rivers or gated boundaries.

It outputs edge-based service areas that do not bridge water barriers, computes 2SFCA spatial access indices for healthcare, and formulates facility location models with PuLP or OR-Tools. For public transit, verifying GTFS calendar dates is mandatory, because an expired transit feed collapses transit calculations into walking times.

What it helps with

  • calculate large many-to-many origin-destination cost matrices in r5py or pandana
  • generate realistic isochrones and service areas respecting natural barriers
  • evaluate healthcare and facility coverage using the 2SFCA method
  • solve facility location-allocation tasks using p-median or maximum coverage

Example prompts for the agent

  • Generate 15-minute walking isochrones around local clinics using OSMnx
  • Compute transit accessibility to jobs across morning rush hour with r5py and GTFS
  • Calculate spatial accessibility scores for hospitals using the 2SFCA method

How to install network-accessibility-analysis

1Skills CLI (Vercel)

npx skills add muend/geoai-skills --skill network-accessibility-analysis -a claude-code

2Manually: put the files in place

~/.claude/skills/network-accessibility-analysis/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/network-accessibility-analysis/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about network-accessibility-analysis

How to install network-accessibility-analysis in Claude Code?

Run this terminal command: npx skills add muend/geoai-skills --skill network-accessibility-analysis -a claude-code.

What does network-accessibility-analysis do?

It provides structured workflows for network-based travel time modeling, facility accessibility, and route analysis. It steers the agent away from Euclidean distance estimates toward verified road and transit graphs.

When does the skill switch away from NetworkX?

NetworkX chokes on metro-scale matrices with more than 10⁴×10⁴ origin-destination pairs. For workloads of that size, the skill directs the agent to pandana or r5py instead of looping shortest-path routines.

Source text

SKILL.md · MIT
---
name: network-accessibility-analysis
description: >-
  Always invoke for access to facilities or opportunities by walking,
  driving, cycling, or public transport, even for a conceptual question with
  no routing terms or data yet. Covers hospital and service access,
  transit/GTFS, routes, isochrones, OD matrices, closest facility, 2SFCA,
  walkability, coverage, and equity. Invoke when Euclidean buffers proxy for
  network access. Use movement-trajectory for observed tracks and MCDA for
  suitability without network costs.
license: MIT
metadata:
  author: Muhammed Enes Duran
---

# Network & Accessibility Analysis

Purpose: replace as-the-crow-flies guesswork with network-true travel
costs, at the right scale and with honest assumptions about speeds and
modes. First decision on every task: Euclidean distance is only acceptable
as a declared approximation — flag it whenever you see it standing in for
access.

## Tool selection by scale

| Scale | Tool |
|---|---|
| Neighborhood-city, research flexibility | **OSMnx + NetworkX** |
| City-region, many-to-many OD (>10⁴×10⁴) | **r5py** (multimodal + transit w/ GTFS) or **pandana** (contraction-hierarchy speed) |
| Production routing service | Valhalla / OSRM / OpenRouteService API |
| Proprietary stacks | ArcGIS Network Analyst (script it headlessly) |

NetworkX chokes on metro-scale many-to-many — don't loop `shortest_path`
over thousands of origins; switch tools instead.

## Graph construction (OSMnx)

```python
import osmnx as ox

G = ox.graph_from_place("City, Country", network_type="drive")  # walk/bike/all
G = ox.add_edge_speeds(G)          # imputes from highway tags where maxspeed missing
G = ox.add_edge_travel_times(G)    # edge attr: travel_time (s)
G = ox.project_graph(G)            # metric CRS before any distance work
```

- **network_type matters**: pedestrian analysis on a `drive` graph misses
  paths, stairs, plazas; driving on `all` uses footpaths. Match mode.
- Imputed speeds are averages by road class — a systematic bias, not
  noise. State it; calibrate against known trips when stakes are high.
- Keep the strongly connected component for routing
  (`ox.truncate.largest_component(G, strongly=True)`); orphan islands
  cause spurious infinities.
- **Snapping**: origins/destinations map to nearest nodes/edges
  (`ox.distance.nearest_nodes`). Report the snap-distance distribution;
  a facility snapped 2 km away (riverside, gated area) silently corrupts
  results.

## Core products

- **Isochrones / service areas**: ego-graph by travel_time cutoff → alpha
  shape or buffered edge union around reached edges. Node-based convex
  hulls overstate coverage across rivers/highways — prefer edge-based
  polygons. Always label the assumptions: mode, speed model, cutoff.
- **OD matrix**: many-to-many travel costs; the substrate for
  accessibility and location-allocation. For big matrices use
  pandana/r5py; store as Parquet with origin/destination IDs.
- **Closest facility**: k-nearest by network cost (not Euclidean); report
  both the assigned facility and the cost.
- **Centrality**: betweenness on travel_time (sampled `k` for big
  graphs — exact is O(nm)); edge betweenness ≈ through-traffic potential.
  Interpret as network structure, not observed traffic.

## Accessibility metrics — pick deliberately

| Metric | Question it answers | Weakness |
|---|---|---|
| Cumulative opportunities (# jobs/POIs within T min) | Simple, communicable | Cliff at T; all-or-nothing |
| Gravity-based (distance-decayed sum) | Smooth access | Decay parameter must be justified |
| **2SFCA / E2SFCA** | Supply-demand ratio access (health care standard) | Catchment size choice drives results |
| Closest-facility time | Worst-case need | Ignores capacity/congestion |

For equity analyses, join metrics to population/demographic polygons
(area-weighted or dasymetric — see `geo-data-engineering`) and report
distributions per group, not just city means. Route statistical testing of
disparities to `spatial-statistics`.

## Location-allocation

Optimal siting (p-median, max-coverage) on the OD matrix: formulate with
PuLP/OR-Tools; inputs are the OD matrix + demand weights + candidate
sites. State the objective explicitly — minimize mean travel time
(p-median) vs maximize covered demand within T (max-coverage) give
different answers, and stakeholders rarely know which they asked for.
Feed results back to `mcda-suitability-analysis` when siting mixes network
access with other criteria.

## Transit (GTFS)

Use r5py with OSM + GTFS feeds; results are departure-time sensitive —
compute over a time window (e.g., 07:00-09:00 percentiles), never a single
departure. Validate the feed (calendar coverage on your analysis date!) —
an expired GTFS calendar yields walking-only times that look plausible.

## Verification protocol

1. Spot-check 3 routes against an external router (Google/OSRM) — within
   ~20% or explain why.
2. Map unreachable/infinite-cost pairs — usually snapping or connectivity
   artifacts, not real inaccessibility.
3. Isochrone eyeball: does it respect rivers, highways, one-ways?

## Pitfalls checklist

- Euclidean buffers presented as "service areas".
- Wrong network_type for the mode.
- Convex-hull isochrones bridging barriers.
- Snap distances unchecked.
- One departure time for transit accessibility.
- Betweenness sold as traffic volume.
- OD matrix in degrees-CRS travel "distances".

## Execution contract

- **Workflow:** define mode, time, impedance, origins, destinations, and equity question; build and validate the network; snap inputs; compute routes or matrices; summarize access; verify.
- **Decision rules:** use network costs for constrained travel, movement analytics for observed tracks, and MCDA only when accessibility becomes one criterion in a broader preference model.
- **Verification protocol:** audit connectivity and snapping, spot-check routes, map unreachable pairs, test departure-time or impedance sensitivity, and reconcile OD dimensions and units.
- **Failure modes:** withhold access claims for disconnected graphs, wrong mode or turn rules, expired GTFS service, excessive snapping, Euclidean substitution, or unstable departure-time results.
- **Deliverables:** network provenance, assumptions and cost function, routes or OD matrix, isochrones or access metrics, unreachable-case report, validation evidence, and equity caveats.
- **Source freshness:** consult [the authoritative source registry](references/authoritative-sources.md) before using network, GTFS, or routing APIs and archive source dates.

© Muhammed Enes Duran · MIT · muend/geoai-skills

Similar skills

All skills for Data and databases →

From the same set18

spatial-statistics A skill that pushes your agent through spatial statistics: clustering, hot spots, dependence, and the diagnostics a regression needs afterwards. CX Codex +1 ★ 35repo stars remote-sensing-analysis Harmonizes satellite and aerial imagery across processing levels, builds STAC pipelines, and handles cloud masking or spectral indices before running analysis. CX Codex +1 ★ 35repo stars postgis-spatial-sql This skill guides spatial SQL backend choices and query design across PostGIS and DuckDB Spatial. Use it to inspect SRIDs, spatial indexes, joins, and query plans. CX Codex +1 ★ 35repo stars point-cloud-lidar A skill for LAS, LAZ and COPC data: ground classification, DTM/DSM/CHM surfaces, canopy and building metrics, vertical datums. Useful when the input is a raw cloud. CX Codex +1 ★ 35repo stars movement-trajectory This skill guides GPS/GNSS track cleaning, stop and trip detection, road matching, and flow aggregation. Use it when you need to turn timestamped locations into movement analysis. CX Codex +1 ★ 35repo stars ml-experiment-standards Makes the agent audit leakage, pick splits and justify metrics before a model gets trained. Useful when a result has to replicate, not just look good. CX Codex +1 ★ 35repo stars mcda-suitability-analysis Guides spatial multi-criteria suitability analysis, AHP factor weighting, and model sensitivity testing across GIS rasters. CX Codex +1 ★ 35repo stars google-earth-engine This skill guides Google Earth Engine workflows for satellite imagery, from filtering collections to computing zonal statistics and exporting results. CX Codex +1 ★ 35repo stars

Project sponsors

Companies that keep this analytics open
Gold sponsor

Impressions, clicks and code copies — open statistics. We keep the numbers public for the same reason NeBlask itself is public. Become a sponsor