Gemini Autoresearch

https://github.com/supratikpm/gemini-autoresearch
Admin
An autonomous improvement engine that runs iterative experiments overnight to optimize code,...
Tokens:17,931
Snippets:261
Trust Score:5.2
Update:5 months ago
Show doc for...
Tokens:
Raw
### Examples of Plan Workflow Goals

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/plan-workflow.md

These examples demonstrate how to phrase your improvement goals for the plan workflow.

```bash
/autoresearch:plan improve test coverage
```

```bash
/autoresearch:plan make the app faster
```

```bash
/autoresearch:plan reduce the bundle size
```

```bash
/autoresearch:plan fix all TypeScript errors
```

```bash
/autoresearch:plan improve the SEO of my blog posts
```

```bash
/autoresearch:plan shrink the Docker image
```

--------------------------------

### Per-Project Skill Installation

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Install the autoresearch skill for a specific project.

```bash
mkdir -p .gemini/skills
cp -r gemini-autoresearch/skills/autoresearch .gemini/skills/autoresearch
```

--------------------------------

### New domain example template

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Use this template when adding a new domain example, specifying the goal, scope, metric, and verification command.

```markdown
/autoresearch
Goal:   <specific, measurable goal>
Scope:  <files or directories to modify>
Metric: <metric name> (higher/lower is better)
Verify: <shell command that outputs a number>
Guard:  <optional — command that must always pass>
```

--------------------------------

### Global Skill Installation

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Install the autoresearch skill globally for use in all projects.

```bash
mkdir -p ~/.gemini/skills
cp -r gemini-autoresearch/skills/autoresearch ~/.gemini/skills/autoresearch
```

--------------------------------

### Example Lesson Structure

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

This is an example of a structured lesson written by Gemini after successful iterations. Lessons help Gemini avoid known failures in subsequent runs.

```markdown
## Lesson 3 — iterations 11–15
Pattern:       Deferring non-critical third-party scripts
Why it worked: Removes scripts from the critical render path
Conditions:    Analytics, chat widgets, social embeds
Anti-pattern:  Lazy-loading scripts called in the first 500ms caused layout shifts
Metric delta:  +6.8% Lighthouse performance
```

--------------------------------

### Install Gemini Autoresearch CLI

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Clone the repository and copy the autoresearch skill to your Gemini CLI skills directory. Choose global or project-specific installation.

```bash
# 1. Clone this repo
git clone https://github.com/supratikpm/gemini-autoresearch.git

# 2a. Install globally — works in ALL your projects
cp -r gemini-autoresearch/skills/autoresearch ~/.gemini/skills/autoresearch

# 2b. Or install for this project only
cp -r gemini-autoresearch/skills/autoresearch .gemini/skills/autoresearch

# 3. Enable in Gemini CLI
# Open Gemini CLI → type /settings → enable Agent Skills
```

--------------------------------

### Good Lesson Example

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/lessons-system.md

An example of a well-structured lesson, detailing a specific pattern, its mechanistic explanation, applicable conditions, a contrasting anti-pattern, and its measured metric delta. This format aids in effective learning for the autoresearch agent.

```markdown
**Pattern**: Defer non-critical third-party scripts using loading="lazy"
**Why it worked**: Removes scripts from the critical render path, reducing
  Time to Interactive without affecting functionality
**Conditions**: Applies to analytics, chat widgets, social embeds — not
  to scripts required for initial page render
**Anti-pattern**: Lazy-loading scripts that are called in the first 500ms
  of page load caused layout shifts and broke interactions
**Metric delta**: +6.8% Lighthouse performance score across 3 iterations
```

--------------------------------

### Autoresearch Verify and Guard Example

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Example of 'Verify' and 'Guard' commands for the autoresearch loop. 'Verify' measures progress towards the goal (e.g., test coverage), while 'Guard' ensures unrelated invariants are maintained (e.g., TypeScript compilation).

```bash
Verify: npm test -- --coverage | grep "All files"
Guard:  npx tsc --noEmit
```

--------------------------------

### Cross-Agent Skill Installation

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Install the autoresearch skill for use with other agents like Claude Code or Cursor.

```bash
mkdir -p .agents/skills
cp -r gemini-autoresearch/skills/autoresearch .agents/skills/autoresearch
```

--------------------------------

### Example Log Rows

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/loop-protocol.md

Illustrates the expected format and content for log entries, showing different statuses like 'baseline', 'keep', 'discard', and 'crash'.

```text
0	-	85.2	0.0	baseline	initial measurement
1	a1b2c3d	87.1	+1.9	keep	lazy-load avatar component
2	-	86.5	-0.6	discard	tree-shake lodash imports (broke 2 tests)
3	-	0.0	0.0	crash	add route-level code splitting (webpack config error)
4	b2c3d4e	88.3	+1.2	keep	move analytics script to defer loading
```

--------------------------------

### Install Gemini Autoresearch for Antigravity IDE

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Copy the autoresearch skill to the .agents/skills/ directory. Antigravity IDE auto-discovers skills here.

```bash
cp -r gemini-autoresearch/skills/autoresearch .agents/skills/autoresearch
```

--------------------------------

### Autoresearch Setup Phase - Initialize Results Log

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

This command initializes the 'autoresearch-results.tsv' file, which logs the progress of the autoresearch loop. It includes columns for iteration, commit hash, metric value, delta, status, guard status, and a description.

```bash
iteration	commit	metric	delta	status	guard	description
0	-	<baseline>	0.0	baseline	pass	initial measurement
```

--------------------------------

### Update Gemini CLI

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Install the latest version of the Gemini CLI to ensure compatibility with skills.

```bash
npm install -g @google/gemini-cli@latest
gemini --version
```

--------------------------------

### Gemini-native Enhancement - Search Queries

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Example search queries for Gemini-native enhancement to check for known issues and security advisories beyond local checks.

```text
Search: [your framework] [version] known issues [current year]
Search: [your main dependencies] security advisory [current year]
```

--------------------------------

### Example Verify Command for Test Coverage

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/GUIDE.md

This shell command extracts the test coverage percentage from npm test output. Ensure your verification command outputs a single number and completes within 10 seconds.

```bash
npm test -- --coverage | grep "All files" | awk '{print $NF}'
```

--------------------------------

### Bad Lesson Example

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/lessons-system.md

An example of a poorly structured lesson, characterized by vague and non-actionable statements. This format is not effective for the autoresearch agent's learning process.

```markdown
**Pattern**: Make things faster
**Why it worked**: It improved performance
**Conditions**: When performance is bad
**Anti-pattern**: When it makes things worse
```

--------------------------------

### Autoresearch Plan Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Use this command when unsure where to start. Gemini will scan your project, detect the tech stack, propose a configuration, and run a dry run.

```bash
/autoresearch:plan make my app faster
/autoresearch:plan improve test coverage
/autoresearch:plan reduce my Docker image size
```

--------------------------------

### Ship Report - Success

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Example of a successful ship report indicating all gates passed and the project is ready to ship.

```text
=== Ship report ===
Tests:	v PASS  (247 passing)
Types:	✓ PASS  (0 errors)
Lint:	✓ PASS  (0 errors)
Bundle:	✓ PASS  (187KB)
Secrets:✓ PASS  (none detected)
Deps:	✓ PASS  (0 high/critical)

Autoresearch loops run: <N>
Total improvements: <M> iterations kept

Ready to ship. Run: git push && <your deploy command>
===
```

--------------------------------

### Standard Autoresearch Loop Invocation

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Use this command to start the autoresearch loop. Provide a specific goal, the scope of files to modify, the metric to optimize, and a shell command to verify progress. A guard command is optional but recommended to ensure unrelated code does not break.

```bash
/autoresearch
Goal:   <what to improve — be specific>
Scope:  <files or directories you may modify>
Metric: <the number you are optimising, and whether higher or lower is better>
Verify: <shell command that measures progress — must output a number in under 10s>
Guard:  <shell command that must always pass — optional but strongly recommended>
```

--------------------------------

### Security Audit Summary Output

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

This is an example of the summary output printed at the end of the security audit. It provides counts of findings by severity, tested vectors, and OWASP category coverage.

```bash
=== Security audit summary ===
Critical:  <N>
High:      <N>
Medium:    <N>
Low:       <N>
Info:      <N>
Vectors tested: <N> / <total>
OWASP categories covered: <list>

Full report: security/audit-<timestamp>/overview.md
===
```

--------------------------------

### Upgrade Autoresearch Skill

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Update the autoresearch skill to the latest version by pulling changes and copying it to your installation path.

```bash
cd gemini-autoresearch && git pull
cp -r skills/autoresearch ~/.gemini/skills/autoresearch  # or your install path
```

--------------------------------

### Overnight Headless Autoresearch

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Runs autoresearch in headless mode using the `--yolo` flag to disable prompts and `--prompt` to start immediately. Results are saved to autoresearch-results.tsv and autoresearch-lessons.md.

```bash
gemini \
  --prompt "Start autoresearch. Goal: reduce bundle size below 200KB. Scope: src/. Metric: KB (lower is better). Verify: npm run build 2>&1 | grep 'First Load JS'. Do not pause." \
  --yolo
```

--------------------------------

### Ship Report - Blocked

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Example of a blocked ship report, showing which gate failed after autoresearch iterations and requires manual intervention.

```text
=== Ship report ===
Tests:	✓ PASS
Types:	✗ FAIL  (3 errors remaining after 20 iterations)
              → manual fix required: src/auth/session.ts:47

Ship BLOCKED. Fix the above before shipping.
===
```

--------------------------------

### Example Autoresearch Results TSV Data

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/results-logging.md

Provides a sample of the autoresearch results log file, demonstrating the structure and content for multiple experiment iterations.

```tsv
iteration	commit	metric	delta	status	description
0	-	85.2	0.0	baseline	initial measurement — test coverage 85.2%
1	a1b2c3d	87.1	+1.9	keep	add tests for auth middleware edge cases
2	-	86.5	-0.7	discard	refactor test helpers (broke 2 existing tests)
3	-	0.0	0.0	crash	add integration tests (postgres connection failed — fix in iter 4)
4	b2c3d4e	88.3	+1.2	keep	add tests for error handling in API routes
5	-	88.1	-0.2	discard	add tests for rate limiter (metric within variance, treated as regression)
6	c3d4e5f	89.0	+0.7	keep	add boundary value tests for form validators
7	d4e5f6g	89.8	+0.8	keep	add tests for session expiry edge cases
8	-	89.2	-0.6	discard	mock external API calls (test isolation but metric regressed)
9	e5f6g7h	90.6	+0.8	keep	add tests for concurrent request handling
10	f6g7h8i	91.1	+0.5	keep	add tests for malformed JSON input handling
```

--------------------------------

### Headless Overnight Autoresearch Execution

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Run the autoresearch skill unattended overnight using the `gemini` command with specific flags. The `--yolo` flag disables confirmation prompts, and `--prompt` starts execution immediately.

```bash
gemini \
  --prompt "Read the autoresearch SKILL.md and start immediately. Goal: <goal>. Scope: <scope>. Metric: <metric — higher/lower is better>. Verify: <command>. Do not pause, do not ask questions, iterate forever." \
  --yolo
```

--------------------------------

### Example Guard Command for TypeScript Compilation

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/GUIDE.md

This command ensures that TypeScript code compiles without errors, serving as a safety check before accepting changes. It's recommended to have a Guard command to prevent regressions.

```bash
npx tsc --noEmit
```

--------------------------------

### Run First Autoresearch

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Initiate your first autoresearch with specified goal, scope, metric, and verification command.

```bash
/autoresearch
Goal:   <your goal>
Scope:  <files or directories to modify>
Metric: <the number you are optimising, higher or lower is better>
Verify: <shell command that outputs the metric>
```

--------------------------------

### Dependency Version Grounding Search Queries

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

Use these queries when the Verify command flags a dependency as potentially outdated, or when optimizing for security or bundle size. Cross-reference results with your package.json.

```text
Search: [package name] npm latest 2026
Search: [package name] security advisory
```

--------------------------------

### Check Per-Project Skills Directory

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

List the contents of the per-project skills directory to troubleshoot 'Skill not found' errors.

```bash
ls .gemini/skills/            # per-project
```

--------------------------------

### Initialize Git Repository

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Initialize a git repository and make an initial commit, which is required for the autoresearch loop's rollback functionality.

```bash
git init
git add -A && git commit -m "initial commit before autoresearch"
```

--------------------------------

### Best Practice Calibration Search Queries

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

When local ideas are exhausted after multiple discards, use these queries to find concrete, actionable techniques from external sources. Add extracted techniques as separate iteration hypotheses.

```text
Search: [language/framework] [metric type] optimisation techniques 2026
Search: how to improve [metric] in [stack]
```

--------------------------------

### Check Global Skills Directory

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

List the contents of the global skills directory to troubleshoot 'Skill not found' errors.

```bash
ls ~/.gemini/skills/          # global
```

--------------------------------

### Invocation Command for Plan Workflow

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/plan-workflow.md

Use this command to initiate the plan workflow by providing your goal in plain English.

```bash
/autoresearch:plan <goal in plain english>
```

--------------------------------

### Autoresearch:plan Subcommand

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Use the ':plan' subcommand to auto-detect the stack, propose goal/scope/verify parameters, and perform a dry run. It prepares a ready-to-run configuration for the autoresearch loop.

```bash
/autoresearch:plan <goal>
```

--------------------------------

### Optimize Blog Post SEO

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe is for optimizing a specific blog post for a target keyword using SEO metrics. It requires Gemini's Google Search grounding and uses a Node.js script for verification.

```bash
Goal:   Maximise SEO score for target keyword "typescript performance"
Scope:  content/blog/typescript-performance.md
Metric: SEO score (higher is better)
Verify: node scripts/seo-score.js content/blog/typescript-performance.md
```

--------------------------------

### Autoresearch Main Loop Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Initiates the main autoresearch loop. Requires Goal, Scope, Metric, and Verify command. Guard command is optional but recommended.

```bash
/autoresearch
Goal:   <what you want to improve>
Scope:  <files or folders the AI may change>
Metric: <what to measure, and whether higher or lower is better>
Verify: <command that outputs the metric>
Guard:  <command that must always pass — optional>
```

--------------------------------

### Reduce Docker Image Size

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe aims to reduce the size of Docker images below a specified limit. It involves building the image and then checking its size using `docker images`.

```bash
Goal:   Reduce Docker image size below 200MB
Scope:  Dockerfile, .dockerignore
Metric: image size in MB (lower is better)
Verify: docker build -t bench . && docker images bench --format "{{.Size}}" | sed 's/MB//'
```

--------------------------------

### Reduce SQL Query Execution Time

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe focuses on optimizing SQL queries for a dashboard to reduce their execution time. It uses `psql` to execute benchmark queries and extracts the total execution time.

```bash
Goal:   Reduce dashboard query execution time
Scope:  queries/dashboard/*.sql
Metric: execution time in ms (lower is better)
Verify: psql -f scripts/bench-queries.sql | grep "total_ms" | awk '{print $2}'
```

--------------------------------

### Confirm Skill Loading

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Verify that the autoresearch skill is loaded in the Gemini CLI.

```bash
/skills
```

--------------------------------

### Verify Skill.md Existence

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Check if the SKILL.md file exists at the root of the skill directory, which is required for the skill to be recognized.

```bash
ls ~/.gemini/skills/autoresearch/SKILL.md
```

--------------------------------

### Reduce Production Bundle Size

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Aim to reduce the production bundle size below a specified limit. This metric is crucial for frontend performance. Ensure tests pass before building.

```bash
/autoresearch
Goal:   Reduce production bundle below 200KB
Scope:  src/**/*.tsx, src/**/*.ts
Metric: bundle size in KB (lower is better)
Verify: npm run build 2>&1 | grep "First Load JS"
Guard:  npm test
```

--------------------------------

### Enable Skills in Gemini CLI

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Access Gemini CLI settings to enable agent skills.

```bash
/settings
```

--------------------------------

### Autoresearch Lessons System Entry

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Append a new lesson to the autoresearch-lessons.md file after every 5 KEPT iterations. Lessons capture patterns, hypotheses, conditions, anti-patterns, and metric deltas.

```markdown
## Lesson <N> — iterations <range>
**Pattern**: <what change type produced gains>
**Why it worked**: <mechanistic hypothesis>
**Conditions**: <when to apply — be specific about codebase state>
**Anti-pattern**: <what failed when trying similar things>
**Metric delta**: <how much the metric moved, cumulative>

```

--------------------------------

### README translation file naming

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Follow this file naming convention for translated README files, using appropriate language codes.

```bash
docs/i18n/README_ZH.md    ← Chinese
docs/i18n/README_HI.md    ← Hindi
docs/i18n/README_BN.md    ← Bengali
docs/i18n/README_JA.md    ← Japanese
docs/i18n/README_KO.md    ← Korean
docs/i18n/README_ES.md    ← Spanish
docs/i18n/README_FR.md    ← French
docs/i18n/README_DE.md    ← German
docs/i18n/README_PT.md    ← Portuguese
docs/i18n/README_RU.md    ← Russian
```

--------------------------------

### Autoresearch Lessons File Format

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/lessons-system.md

This markdown structure defines the format for autoresearch lessons, including pattern, why it worked, conditions, anti-pattern, and metric delta. It should be added to .gitignore as it's a working file.

```markdown
# Autoresearch lessons — <project name>
Generated by gemini-autoresearch. Do not edit manually.
Last updated: <ISO date>

## Lesson 1 — iterations 1–5
**Pattern**: <the type of change that produced gains>
**Why it worked**: <mechanistic hypothesis — be specific>
**Conditions**: <codebase state where this applies>
**Anti-pattern**: <what failed when trying similar approaches>
**Metric delta**: <cumulative gain from this pattern, e.g. "+4.2%">

## Lesson 2 — iterations 6–10
...
```

--------------------------------

### Autoresearch:ship Subcommand

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

The ':ship' subcommand initiates a pre-flight checklist including tests, types, linting, bundling, secrets, and dependency checks. It then runs the autoresearch loop on any failures.

```bash
/autoresearch:ship
```

--------------------------------

### Run Autoresearch Headless Overnight

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Execute autoresearch in headless mode for overnight runs, providing all necessary parameters in the prompt.

```bash
gemini \
  --prompt "Read the autoresearch skill and start immediately. Goal: <goal>. Scope: <scope>. Metric: <metric — higher/lower is better>. Verify: <command>. Do not pause." \
  --yolo
```

--------------------------------

### Configuration via .autoresearch.yml

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

YAML configuration for customizing ship workflow behavior, including bundle size thresholds, max iterations, and custom gates.

```yaml
ship:
  bundle_warn_kb: 300
  bundle_block_kb: 500
  max_iterations_per_gate: 20
  skip_gates:
    - lighthouse    # skip if no local server available
  extra_gates:
    - name: "E2E tests"
      command: "npx playwright test"
      metric: "failing tests (lower is better)"
      max_iterations: 10
```

--------------------------------

### Clone the Autoresearch Skill

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Clone the autoresearch skill repository to your local machine.

```bash
git clone https://github.com/YOUR_USERNAME/gemini-autoresearch.git
```

--------------------------------

### Nightly Learning Cycle

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Illustrates the nightly learning cycle where Gemini writes lessons one night and reads them the next to improve performance and avoid past failures.

```text
Night 1 → 100 experiments → lessons written
Night 2 → reads lessons  → avoids known failures → smarter from the start
Night 3 → reads updated  → compound gains
```

--------------------------------

### Reduce Next.js Production Bundle Size

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe aims to reduce the production bundle size of a Next.js application. It specifies a target size and uses build and lint commands for verification and guarding.

```bash
Goal:   Reduce production bundle below 200KB
Scope:  src/**/*.tsx, src/**/*.ts
Metric: bundle size in KB (lower is better)
Verify: npm run build 2>&1 | grep "First Load JS" | awk '{print $4}'
Guard:  npm run lint
```

--------------------------------

### Hunt for Flaky Tests

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe is designed to identify and eliminate flaky tests by running tests multiple times and counting failures. The goal is to achieve zero failures over a specified number of consecutive runs.

```bash
Goal:   Zero flaky tests (5 consecutive green runs)
Scope:  src/**/*.test.ts
Metric: failure count across 5 runs (lower is better)
Verify: for i in {1..5}; do npm test 2>&1; done | grep -c "FAIL" || echo "0"
```

--------------------------------

### Invocation Options for Security Audit

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

These commands initiate the security audit with different options. Use `--fix` to automatically resolve confirmed findings or `--fail-on` to set a CI gate based on severity. Specify a `--scope` to limit the audit to a particular directory.

```bash
/autoresearch:security                    # full audit, report only
```

```bash
/autoresearch:security --fix              # audit + auto-fix confirmed findings
```

```bash
/autoresearch:security --fail-on critical # exit non-zero if critical found (CI gate)
```

```bash
/autoresearch:security --scope src/api/   # audit a specific directory only
```

--------------------------------

### CI/CD Gate Mode Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

This command demonstrates how to use the CI/CD gate mode with a specified severity level. It's designed to halt CI pipelines if findings at or above the 'critical' severity are detected.

```bash
/autoresearch:security --fail-on critical
```

--------------------------------

### Bug report information

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

When reporting a bug, include details about what you were trying to do, the command used, the outcome, your CLI version, and your OS.

```markdown
What you were trying to do
What command you ran
What happened vs what you expected
Your Gemini CLI version (`gemini --version`)
Your OS
```

--------------------------------

### Autoresearch Plan Output Format

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/plan-workflow.md

This is the final output format of the plan workflow, providing all details for the autoresearch command.

```bash
=== Autoresearch plan ===
Stack:    <detected stack>
Goal:     <interpreted goal>
Scope:    <proposed scope>
Metric:   <metric name> (<higher/lower> is better)
Verify:   <verify command>
Baseline: <dry run result>

Ready to run. Confirm or adjust any field, then:

/autoresearch
Goal:   <goal>
Scope:  <scope>
Metric: <metric>
Verify: <verify command>

Or for headless overnight mode:
gemini --prompt "Start autoresearch. Goal: <goal>. Scope: <scope>. Metric: <metric — higher/lower is better>. Verify: <command>. Do not pause."
===
```

--------------------------------

### Standardize SOPs

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Ensure all Standard Operating Procedures (SOPs) adhere to a standard template with a maximum of 100 words per step. This script checks template compliance.

```bash
/autoresearch
Goal:   All SOPs use standard template with under 100 words per step
Scope:  docs/sops/*.md
Metric: template compliance % (higher is better)
Verify: node scripts/sop-score.js
```

--------------------------------

### Gate 4: Check Bundle Size

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Measures the JavaScript bundle size for frontend projects. Exceeding thresholds can block shipping and trigger autoresearch.

```bash
npm run build 2>&1 | grep "First Load JS"
```

--------------------------------

### Benchmark Calibration Search Query

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

Use this query to compare your current metric value against industry benchmarks. If your metric meets or exceeds the industry median, consider refining your goal definition.

```text
Search: [framework] [metric] benchmark 2026 average
```

--------------------------------

### GitHub Actions CI/CD Integration

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

This YAML snippet shows how to integrate the security audit into a GitHub Actions workflow. It uses the `--fail-on critical` flag to ensure that the pipeline fails if critical security issues are found, leveraging the `--yolo` flag for the Gemini tool.

```yaml
# .github/workflows/security.yml
- name: Security audit
  run: gemini --prompt "/autoresearch:security --fail-on critical" --yolo
```

--------------------------------

### Run Gemini Autoresearch in Headless Mode

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Use the `--yolo` flag to disable confirmation prompts for uninterrupted overnight execution. Ensure all configurations are set before running.

```bash
gemini --prompt "..." --yolo
```

--------------------------------

### Increase Jest/Vitest Test Coverage

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

Use this recipe to set a goal for increasing test coverage from a baseline to a target percentage. Ensure tests are run with coverage enabled and use a guard to prevent non-compiling code from being committed.

```bash
Goal:   Increase test coverage from 72% to 90%
Scope:  src/**/*.ts, src/**/*.test.ts
Metric: coverage % (higher is better)
Verify: npm test -- --coverage | grep "All files" | awk '{print $4}'
Guard:  npx tsc --noEmit
```

--------------------------------

### Verification script naming convention

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Name your verification scripts descriptively within the scripts/ directory.

```bash
scripts/lighthouse-score.js
scripts/seo-score.js
scripts/validate-subjects.js
scripts/spam-score.js
```

--------------------------------

### Autoresearch Progress Summary

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Print a summary of the autoresearch progress, including baseline, current best, counts of different outcomes, and recent activity. This is displayed every 10 iterations.

```bash
=== Autoresearch progress — iteration N ===
Baseline:     <value>
Current best: <value> (<delta> from baseline)
Keeps:        <count>
Discards:     <count>
Crashes:      <count>
Top pattern:  <what has worked most consistently>
Last 5:       <keep/discard/crash sequence>
===

```

--------------------------------

### Create a new branch

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Create a new branch for your changes to keep them isolated from the main branch.

```bash
git checkout -b add-playwright-verify-script
```

--------------------------------

### Gate 1: Run Tests

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Executes tests for various programming languages. If tests fail, autoresearch will loop on source files to fix them.

```bash
npm test
```

```bash
pytest
```

```bash
go test ./...
```

```bash
cargo test
```

--------------------------------

### Autoresearch:security Subcommand

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

The ':security' subcommand initiates a STRIDE/OWASP audit loop. It includes threat modeling, vulnerability identification, and optional automated fixing of security issues.

```bash
/autoresearch:security
```

--------------------------------

### Verify Custom Commands Script

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

This script serves as a template for custom verification commands within the Gemini Autoresearch framework. Adapt it to your specific verification needs.

```bash
scripts/verify.sh
```

--------------------------------

### Gate 3: Check Linting

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Runs linters for JavaScript/TypeScript, Python, and Go. Autoresearch can fix auto-fixable linting errors before addressing others.

```bash
npx eslint src/
```

```bash
ruff check src/
```

```bash
golangci-lint run
```

--------------------------------

### Commit changes

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Commit your changes with a clear and descriptive message following the conventional commit format.

```bash
git commit -m "add: Playwright e2e verify script"
```

--------------------------------

### Autoresearch Ship Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Executes a pre-flight checklist before shipping. Includes tests, types, linting, bundle size, secrets scan, and dependency audit. Can run in dry-run or fast mode.

```bash
/autoresearch:ship
/autoresearch:ship --dry-run      ← report only, no fixes
/autoresearch:ship --fast         ← skip slow checks
```

--------------------------------

### Improve Blog Post SEO Ranking

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Maximize the SEO score for a specific blog post using Google Search grounding. This is a Gemini-native feature.

```bash
/autoresearch
Goal:   Maximise SEO score for keyword "project management tips"
Scope:  content/blog/project-management.md
Metric: SEO score (higher is better)
Verify: node scripts/seo-score.js content/blog/project-management.md
```

--------------------------------

### Auto-fix Loop Logic

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

This pseudocode outlines the steps involved in the auto-fix loop, which runs only when the `--fix` flag is passed and targets Critical and High severity findings. It details the process of making, committing, and verifying fixes, including fallback mechanisms for failed attempts.

```pseudocode
FOR EACH confirmed Critical/High finding:
  1. Read the finding + recommendation
  2. Make ONE targeted fix
  3. git commit the fix
  4. Re-run the specific exploit scenario to verify it no longer works
  5. Run full test suite to confirm no regressions
  6. If tests break → revert, try alternative fix
  7. Maximum 3 attempts per finding, then skip and flag for manual review
  8. Log fix outcome to fix-log.md
```

--------------------------------

### Live Threat Intelligence Searches

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

Utilize Google Search to gather current threat intelligence relevant to your technology stack and framework. This helps in identifying recent vulnerabilities and attack patterns.

```bash
Search: [your stack] common vulnerabilities [current year]
```

```bash
Search: [your main framework] CVE [current year]
```

```bash
Search: OWASP top 10 [current year]
```

--------------------------------

### Optimize CI Pipeline Speed

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Aim to reduce the CI pipeline execution time to under 5 minutes. This script estimates the pipeline duration.

```bash
/autoresearch
Goal:   CI pipeline under 5 minutes
Scope:  .github/workflows/*.yml
Metric: estimated pipeline duration in seconds (lower is better)
Verify: node scripts/estimate-ci-time.js
```

--------------------------------

### API Currency Check Search Queries

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

Employ these search queries when refactoring code that interacts with external libraries or APIs. They help detect deprecation notices or breaking changes before committing modifications.

```text
Search: [library name] [method name] changelog 2026
Search: [library name] [method name] deprecated
```

--------------------------------

### Autoresearch Progress Summary Format

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/results-logging.md

Defines the format for printing a progress summary every 10 iterations during an autoresearch run. This includes key metrics and statistics.

```text
=== Autoresearch progress — iteration <N> ===
Goal:         <original goal statement>
Baseline:     <iteration 0 metric>
Current best: <best metric so far> (<total delta> from baseline)
Keeps:        <count> (<keeps/total * 100>%)
Discards:     <count>
Crashes:      <count>
Top pattern:  <the change type that has produced the most total delta>
Last 5:       <sequence of keep/discard/crash for iterations N-4 through N>
Est. to goal: <if goal metric is known, N iterations at current rate>
===
```

--------------------------------

### Reduce Docker Image Size

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Minimize the size of Docker images to optimize deployment and storage. This is verified by checking the image size after a build.

```bash
/autoresearch
Goal:   Reduce Docker image below 150MB
Scope:  Dockerfile, .dockerignore
Metric: image size in MB (lower is better)
Verify: docker build -t bench . -q && docker images bench --format "{{.Size}}"
```

--------------------------------

### Content Accuracy Grounding Search Query

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

When the Verify command assesses style and structure but not factual accuracy, use this query to ground-truth specific claims against authoritative sources. Flag contradictions as required fixes.

```text
Search: [specific claim in content] site:[authoritative source]
```

--------------------------------

### Improve Lighthouse Performance Score

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Target a high Lighthouse performance score for web applications. This involves optimizing frontend assets and rendering. Ensure tests pass before running Lighthouse.

```bash
/autoresearch
Goal:   Lighthouse performance score above 95
Scope:  src/components/**/*.tsx, src/app/**/*.tsx
Metric: Lighthouse score (higher is better)
Verify: npx lighthouse http://localhost:3000 --output json --quiet 2>/dev/null | jq '.categories.performance.score * 100'
Guard:  npm test
```

--------------------------------

### Improve Flesch Readability Score

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe aims to improve the Flesch-Kincaid readability grade level of a landing page. It uses the `alex` tool to check for readability warnings and aims for a specific grade level.

```bash
Goal:   Maximise Flesch-Kincaid grade level consistency (aim for Grade 8)
Scope:  content/landing-pages/home.md
Metric: score (higher is better)
Verify: npx alex content/landing-pages/home.md | grep -c "warning" || echo "100"
```

--------------------------------

### Run Ship Workflow

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Invokes the ship workflow. Optional flags can be used to skip slow checks, limit autoresearch iterations, or perform a dry run.

```bash
/autoresearch:ship
```

```bash
/autoresearch:ship --fast
```

```bash
/autoresearch:ship --loop N
```

```bash
/autoresearch:ship --dry-run
```

--------------------------------

### Remove Unused CSS/Tailwind Classes

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe focuses on reducing CSS file size by removing unused Tailwind classes. It involves building the project and then checking the size of the generated CSS files.

```bash
Goal:   Remove all unused Tailwind classes
Scope:  src/components/**/*.tsx, tailwind.config.js
Metric: CSS file size (lower is better)
Verify: npm run build && ls -lh dist/assets/*.css | awk '{print $5}'
```

--------------------------------

### SEO Content Verification Search Query

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/google-search-patterns.md

Use this pattern to analyze top search results for SEO content optimization. It helps identify common traits like heading structure, content length, and semantic coverage among competing pages.

```text
Search: [target keyword] to see what the top 3 results have in common.
Note: heading structure, content length, semantic coverage, internal links.
If top results consistently have trait X that your content lacks,
add "add trait X" as the next hypothesis.
```

--------------------------------

### Push changes

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Push your new branch with the committed changes to your remote fork.

```bash
git push origin add-playwright-verify-script
```

--------------------------------

### Optimize Email Subject Lines

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Generate 40 email subject lines that meet specific criteria: under 50 characters, include a power word, and a CTA. This script validates the generated lines.

```bash
/autoresearch
Goal:   40 subject lines, each under 50 chars with a power word and CTA
Scope:  content/emails/subject-lines.md
Metric: lines meeting all criteria (higher is better)
Verify: node scripts/validate-subjects.js
```

--------------------------------

### Optimize SQL Query Performance

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Reduce the total execution time for dashboard SQL queries. This involves analyzing and optimizing query performance.

```bash
/autoresearch
Goal:   Reduce dashboard query total execution time
Scope:  queries/dashboard/*.sql
Metric: total execution time in ms (lower is better)
Verify: psql -f scripts/bench-queries.sql | grep "total_ms"
```

--------------------------------

### Git Commit for Autoresearch Iteration

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/loop-protocol.md

Use this command to add all changes and commit them with a descriptive message. Always prefix the commit message with 'autoresearch iter N:'.

```bash
git add -A && git commit -m "autoresearch iter N: <one-sentence description>"
```

--------------------------------

### Increase Test Coverage

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Use this to increase test coverage from a baseline percentage to a target. Ensure TypeScript compilation passes before running tests.

```bash
/autoresearch
Goal:   Increase test coverage from 72% to 90%
Scope:  src/**/*.ts, src/**/*.test.ts
Metric: coverage % (higher is better)
Verify: npm test -- --coverage | grep "All files"
Guard:  npx tsc --noEmit
```

--------------------------------

### Add Autoresearch Files to .gitignore

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/INSTALL.md

Add generated autoresearch working files to your .gitignore to prevent them from being tracked by git.

```bash
echo "autoresearch-results.tsv" >> .gitignore
echo "autoresearch-lessons.md" >> .gitignore
```

--------------------------------

### Gate 2: Check Types

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Verifies type correctness using TypeScript or Python's MyPy. Autoresearch will attempt to fix type errors if found.

```bash
npx tsc --noEmit
```

```bash
mypy src/
```

--------------------------------

### Improve Job Description Inclusivity

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Ensure job descriptions use bias-free, inclusive language. This script calculates an inclusivity score.

```bash
/autoresearch
Goal:   Bias-free, inclusive language across all job descriptions
Scope:  content/job-descriptions/*.md
Metric: inclusivity score (higher is better)
Verify: node scripts/jd-inclusivity-score.js
```

--------------------------------

### Autonomous Audit Loop Logic

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/security-workflow.md

This pseudocode outlines the autonomous audit loop. It iterates through attack vectors, deep-dives into code, constructs exploit scenarios, validates with evidence, classifies findings, and logs results.

```pseudocode
LOOP (through all attack vectors from threat model):
  1. Select next untested attack vector
  2. Deep-dive into the relevant code (read fully — do not skim)
  3. Attempt to construct a concrete exploit scenario
  4. Validate with code evidence (file:line + exact scenario)
  5. Classify: severity + OWASP category + STRIDE tag
  6. Log to security-audit-results.tsv
  7. Print coverage summary every 5 iterations
  8. Continue until all vectors tested
```

--------------------------------

### Autoresearch Debug Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Performs autonomous root cause analysis for broken components. It reproduces the failure, isolates the cause, fixes it, and verifies the fix.

```bash
/autoresearch:debug the auth tests are failing
/autoresearch:debug TypeError: Cannot read property 'id' of undefined
/autoresearch:debug CI is failing on the build step
```

--------------------------------

### Gate 6: Audit Dependencies

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Checks for high or critical vulnerabilities in project dependencies. Autoresearch can be used to update vulnerable packages.

```bash
npm audit --audit-level=high
```

```bash
pip-audit
```

--------------------------------

### Eliminate TypeScript Errors

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/docs/EXAMPLES.md

This recipe focuses on achieving a zero-error state for TypeScript compilation. It uses `npx tsc --noEmit` to check for errors and counts them to ensure all are resolved.

```bash
Goal:   Eliminate all TypeScript errors
Scope:  src/**/*.ts
Metric: error count (lower is better)
Verify: npx tsc --noEmit 2>&1 | grep -c "error TS" || echo "0"
```

--------------------------------

### Improve Landing Page Quality Score

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Maximize the Conversion Rate Optimization (CRO) score for landing pages by ensuring clear CTAs, social proof, urgency, and readability. This script calculates the CRO score.

```bash
/autoresearch
Goal:   Maximise CRO score — clear CTA, social proof, urgency, readability
Scope:  content/landing-pages/home.md
Metric: CRO score (higher is better)
Verify: node scripts/cro-score.js content/landing-pages/home.md
```

--------------------------------

### Autoresearch Security Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

Conducts a full STRIDE and OWASP security audit with code evidence for each finding. Supports optional auto-fixing for critical and high findings and CI gate mode.

```bash
/autoresearch:security
/autoresearch:security --fix                 ← auto-fix confirmed findings
/autoresearch:security --fail-on critical    ← CI gate mode
```

--------------------------------

### Pull request title format

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/CONTRIBUTING.md

Follow this format for your pull request titles to clearly indicate the type of change.

```markdown
add: <what you added>
fix: <what you fixed>
docs: <what you documented>
translate: README into <language>
```

--------------------------------

### Log Autoresearch Results

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Append a row to the autoresearch-results.tsv file with detailed iteration information. This format is used for tracking progress and outcomes.

```bash
<N>	<commit_sha or "-">	<metric_value>	<delta>	<keep|discard|guard-fail|crash>	<guard:pass|fail|skip>	<description>
```

--------------------------------

### Autoresearch:debug Subcommand

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Invoke the ':debug' subcommand for an autonomous debug loop. This process involves reproducing the issue, isolating the root cause, fixing it, verifying the fix, and hardening the codebase.

```bash
/autoresearch:debug <description>
```

--------------------------------

### Autoresearch Log Row Format

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/loop-protocol.md

Defines the Tab-Separated Values (TSV) format for logging each iteration's outcome. Ensure all fields are correctly populated for machine readability.

```text
<N>	<commit_sha or "-">	<metric>	<delta>	<status>	<description>
```

--------------------------------

### Autoresearch:fix Subcommand

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/SKILL.md

Use the ':fix' subcommand for a focused fix loop, specifically targeting lint, type, or test failures without requiring full debug isolation. It aims to resolve specific issues efficiently.

```bash
/autoresearch:fix <description>
```

--------------------------------

### Eliminate TypeScript Errors

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

This goal focuses on achieving zero TypeScript errors in the codebase. It's a fundamental step for maintaining code quality.

```bash
/autoresearch
Goal:   Eliminate all TypeScript errors
Scope:  src/**/*.ts
Metric: error count (lower is better)
Verify: npx tsc --noEmit 2>&1 | grep -c "error TS" || echo "0"
```

--------------------------------

### Gemini-Native LLM-as-Judge Scorer

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/README.md

This JavaScript file implements a scorer using an LLM, designed to function natively within the Gemini environment. It's used for evaluating content based on specific criteria.

```javascript
scripts/content-score.js
```

--------------------------------

### Revert Commit Command

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/loop-protocol.md

Use this command to undo the last commit. It preserves history, unlike `git reset --hard`.

```bash
git revert HEAD --no-edit
```

--------------------------------

### Gate 5: Check for Hardcoded Secrets

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/ship-workflow.md

Scans code changes for hardcoded secrets like API keys or passwords. This gate does not use autoresearch and blocks shipping if secrets are found.

```bash
git diff HEAD~1 --diff-filter=A | grep -iE "(api_key|secret|password|token)\s*=\s*['\"][^'\"]{8,}"
```

--------------------------------

### Archive Autoresearch Results TSV

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/results-logging.md

Command to archive the autoresearch results TSV file by renaming it with a date stamp. This is a file hygiene practice between runs.

```bash
mv autoresearch-results.tsv autoresearch-results-<date>.tsv
```

--------------------------------

### Autoresearch Results TSV Header

Source: https://github.com/supratikpm/gemini-autoresearch/blob/main/skills/autoresearch/references/results-logging.md

Defines the header row for the autoresearch results tab-separated values file. This format is used for logging each experiment iteration.

```tsv
iteration	commit	metric	delta	status	description
```
Tokens:
Raw