Skip to main content
skill CX Codex

first-order-model-fitting — Claude Code skill

The first-order-model-fitting skill fits first-order models to experimental step responses and returns K and tau. Use it when you need a compact model of thermal, electrical, or mechanical behavior.

Apache-2.0 1 installs ★ 1,933 updated 2026-10-24

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add benchflow-ai/skillsbench --skill first-order-model-fitting -a claude-code
Open on GitHub

What first-order-model-fitting does

The skill models a step response with a first-order differential equation and estimates the process gain K plus the time constant tau. It uses the baseline output y_ambient, the known input step u, and measured output values over time.

It includes the fitting equations, Python model functions, and practical guidance for selecting the data range. After fitting, you can calculate R-squared and RMS fitting error to compare the curve with measurements. The initial flat segment should be left out when it belongs to the period before the input changes.

A known input step u and a baseline y_ambient are required for this model to produce meaningful K and tau values.

What it helps with

  • estimate process gain K from the steady-state response
  • find tau from the 63.2% rise point
  • fit a first-order curve to measured data
  • remove the pre-step flat segment
  • calculate R-squared and RMS fitting error

Example prompts for the agent

  • Fit K and tau to the step-response data in step_response.csv using the known u and y_ambient.
  • Write Python code for a first-order curve fit and calculate R-squared plus RMS fitting error.
  • Check whether the initial flat segment should be removed before fitting the data in experiment.csv.

How to install first-order-model-fitting

1Skills CLI (Vercel)

npx skills add benchflow-ai/skillsbench --skill first-order-model-fitting -a claude-code

2Manually: put the files in place

~/.claude/skills/first-order-model-fitting/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/first-order-model-fitting/

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

Questions about first-order-model-fitting

How do I install first-order-model-fitting in Claude Code?

Run npx skills add benchflow-ai/skillsbench --skill first-order-model-fitting -a claude-code, then check ~/.claude/skills/first-order-model-fitting/SKILL.md.

What does first-order-model-fitting do?

It fits a first-order dynamic model to an experimental step response and extracts K and tau. It also covers R-squared and RMS fitting error calculations.

What data does the skill need to estimate K and tau?

Provide time-series output measurements, the known input step u, and the baseline y_ambient. Tau is obtained from the time required to reach 63.2% of the final output change.

Source text

SKILL.md · Apache-2.0
---
name: first-order-model-fitting
description: Fit first-order dynamic models to experimental step response data and extract K (gain) and tau (time constant) parameters.
---

# First-Order System Model Fitting

## Overview

Many physical systems (thermal, electrical, mechanical) exhibit first-order dynamics. This skill explains the mathematical model and how to extract parameters from experimental data.

## The First-Order Model

The dynamics are described by:

```
tau * dy/dt + y = y_ambient + K * u
```

Where:
- `y` = output variable (e.g., temperature, voltage, position)
- `u` = input variable (e.g., power, current, force)
- `K` = process gain (output change per unit input at steady state)
- `tau` = time constant (seconds) - characterizes response speed
- `y_ambient` = baseline/ambient value

## Step Response Formula

When you apply a step input from 0 to u, the output follows:

```
y(t) = y_ambient + K * u * (1 - exp(-t/tau))
```

This is the key equation for fitting.

## Extracting Parameters

### Process Gain (K)

At steady state (t -> infinity), the exponential term goes to zero:

```
y_steady = y_ambient + K * u
```

Therefore:

```
K = (y_steady - y_ambient) / u
```

### Time Constant (tau)

The time constant can be found from the 63.2% rise point:

At t = tau:
```
y(tau) = y_ambient + K*u*(1 - exp(-1))
       = y_ambient + 0.632 * (y_steady - y_ambient)
```

So tau is the time to reach 63.2% of the final output change.

## Model Function for Curve Fitting

```python
def step_response(t, K, tau, y_ambient, u):
    """First-order step response model."""
    return y_ambient + K * u * (1 - np.exp(-t / tau))
```

When fitting, you typically fix `y_ambient` (from initial reading) and `u` (known input), leaving only `K` and `tau` as unknowns:

```python
def model(t, K, tau):
    return y_ambient + K * u * (1 - np.exp(-t / tau))
```

## Practical Tips

1. **Use rising portion data**: The step response formula applies during the transient phase
2. **Exclude initial flat region**: Start your fit from when the input changes
3. **Handle noisy data**: Fitting naturally averages out measurement noise
4. **Check units**: Ensure K has correct units (output units / input units)

## Quality Metrics

After fitting, calculate:
- **R-squared (R^2)**: How well the model explains variance (want > 0.9)
- **Fitting error**: RMS difference between model and data

```python
residuals = y_measured - y_model
ss_res = np.sum(residuals**2)
ss_tot = np.sum((y_measured - np.mean(y_measured))**2)
r_squared = 1 - (ss_res / ss_tot)
fitting_error = np.sqrt(np.mean(residuals**2))
```

© benchflow-ai · Apache-2.0 · benchflow-ai/skillsbench

Similar skills

All skills for Science and research →

From the same set22

The whole set →
civ6lib civ6lib validates Civilization 6 district placement and computes adjacency bonuses. Use it when an agent needs to reason about city layouts and game rules. CX Codex +1 2installs meteorology-driver-classification meteorology-driver-classification sorts the columns of an environmental dataset into heat, flow, wind and human drivers, so an attribution run can treat each group as one factor. CX Codex +1 2installs scipy-curve-fit scipy-curve-fit guides coding agents to estimate nonlinear model parameters from experimental data with scipy.optimize.curve_fit. CX Codex +1 2installs python-scala-idioms python-scala-idioms guides AI agents to translate Python into idiomatic Scala. Enforces immutability, pattern matching, sealed domain traits, and type-safe error handling. CX Codex +1 1installs hex-grid-spatial hex-grid-spatial is a Claude Code skill that calculates neighbours, hex distance, and radius cells on odd-r offset maps for movement or area-of-effect logic. CX Codex +1 1installs python-scala-syntax-mapping python-scala-syntax-mapping is a Claude Code skill that maps Python syntax to Scala for coding assistants translating variables, comprehensions, and control structures. CX Codex +1 1installs image-ocr Use this skill to read text in images with Tesseract OCR through Python. It fits scans, screenshots, and batches of image files. CX Codex +1 1installs audiobook Turns a web article or a text file into an audiobook: pulls the content, cleans it up, and voices it through ElevenLabs, OpenAI TTS or gTTS. CX Codex +1 1installs

Project sponsors

Companies that keep this analytics open