Results for “iterative”

Detect distant homologs using profile and structure-aware methods that go beyond standard BLAST. Use when sequence identity falls into the twilight zone (<35% pairwise), when BLAST fails to find homologs that should exist, when working at metagenomic scale (DIAMOND, MMseqs2), or when structure beats sequence (Foldseek). Covers PSI-BLAST (iterative PSSM), jackhmmer (iterative HMM), HHblits/HHsearch (profile-profile), DIAMOND, MMseqs2, and Foldseek (3Di structural alphabet, van Kempen 2024).

The English summary is being prepared. Showing the original description.

Build a differential-ready consensus peakset from per-replicate ATAC-seq peaks using iterative overlap removal, fixed-width re-centering, and majority-rule overlap. Use when generating a stable peak coordinate system for downstream differential accessibility, ML feature engineering, cross-sample comparison, or fixed-width peak counts; covers Corces 2018 iterative overlap (501 bp), DiffBind summit re-centering, and ENCODE consistency rules.

The English summary is being prepared. Showing the original description.

Autonomous iterative experimentation loop for any programming task. Guides the user through defining goals, measurable metrics, and scope constraints, then runs an autonomous loop of code changes, testing, measuring, and keeping/discarding results. Inspired by Karpathy's autoresearch. USE FOR: autonomous improvement, iterative optimization, experiment loop, auto research, performance tuning, automated experimentation, hill climbing, try things automatically, optimize code, run experiments, autonomous coding loop. DO NOT USE FOR: one-shot tasks, simple bug fixes, code review, or tasks without a measurable metric.

The English summary is being prepared. Showing the original description.

Iterative Python via live Jupyter kernel (hamelnb).

The English summary is being prepared. Showing the original description.

Gather relevant code and background for subagents, agents assigned part of a larger task. Search broadly, assess each file, identify missing information, and refine the search for up to three cycles to assemble context for bug fixes or feature work.

• Finding relevant files for a subagent assigned a bug fix
• Gathering code patterns before implementing a feature
• Refining searches to match terminology used in a project

Explore data and develop Python code in a live Jupyter session that keeps variables between runs. Inspect objects, edit notebook cells, and optionally restart and run the whole notebook to check execution from top to bottom.

• Exploring data while keeping variables between runs
• Inspecting DataFrames and live Python objects
• Trying API usage and refining complex code

Check a pull request’s title and description against its commits and code changes. Identify missing major changes or outdated claims, propose accurate wording, and apply agreed updates while following the repository’s existing template.

• Check whether a pull request description matches the implementation
• Add major changes missing from a pull request summary
• Update an outdated pull request title

Turn descriptions of scientific components and relationships into PNG diagram drafts with Nano Banana 2. Gemini 3.7 Flash reviews each draft and may request one revision, while saved image versions and review logs support manual checking.

• Drafting neural network architecture diagrams
• Illustrating biological pathways
• Creating study flowcharts

Generate images from written instructions and edit saved or uploaded images using them as references. Continue refining the latest image in a conversation, adjusting details such as brightness, background, or colors while specifying what to preserve.

• Creating an image from a written description
• Editing an uploaded image
• Refining the latest generated image

Turn ideas and reference materials into a blog draft through research, outline approval, and revision. The workflow includes source citations, adjustments for the intended audience and tone, and separate files for each draft version.

• Turning research materials into a blog post
• Planning an article for a specific audience
• Drafting articles with source citations

Add GraalVM Native Image support to Java applications to build native executables. The skill adapts Maven or Gradle configuration, fixes build errors iteratively, and checks application behavior, startup time, and memory use.

• Adding native executable builds to a Java application
• Configuring native builds for Maven or Gradle
• Fixing reflection and resource errors in native builds

Design workflows that evaluate and refine AI outputs through self-review, separate generation and evaluation roles, tests, or weighted scoring criteria. Includes patterns for structured feedback, iteration limits, and stopping when quality stops improving.

• Adding self-review and revision loops to AI outputs
• Separating generation from evaluation
• Refining generated code using test results

Debug local web and Electron apps through a persistent Playwright session in js_repl, an interactive JavaScript environment. Reuse browser connections while checking user interactions, visual states, screen sizes, and screenshots after changes.

• Rechecking an interface after code changes
• Testing buttons and complete user flows
• Inspecting layouts at desktop and mobile widths

Improve writing, prompts, or skills through repeated review cycles that carry forward lessons and rejected approaches. Human feedback guides each pass by default, while saved history supports resuming work and tracking progress.

• Refining a prompt over several passes
• Improving a skill's output quality
• Making diagram instructions more consistent

Structure problem solving around clear goals, competing explanations, experiments, and measurable results. Use the cycle to diagnose bugs, validate features, compare prompts, or evaluate an early product, then choose the next step based on evidence.

• Diagnosing a bug with a quick investigation
• Comparing prompt structures through experiments
• Defining success criteria for a feature

Research topics across multiple sources, cross-check findings, and verify source URLs before producing a report with confidence labels. Choose from quick lookups to iterative investigations that preserve findings, with community sources prioritized for questions about public reactions.

• Compare AI technology trends
• Map a market and its products
• Investigate community reactions

Create model architecture diagrams and method illustrations for academic papers using Gemini. Codex plans the figure and reviews generated images for correct connections, content, layout, and readability, guiding repeated revisions toward a clearer final figure.

• Illustrate a model architecture for a paper
• Show a method's processing steps and data flow
• Create a conceptual comparison diagram

Coordinate a research project from a broad topic through literature review, idea selection, experiments, and iterative review. Produce a research summary for writing, with optional paper drafting and PDF compilation, while recording stage progress for later resumption.

• Taking a broad research topic through experiments and review
• Coordinating experiment implementation and result collection
• Preparing an evidence-based handoff for paper writing

Improve research code, results, and paper drafts through repeated review by a second Codex agent. The workflow implements fixes, checks them again, and records assessments and unresolved issues across up to four rounds.

• Improve research before submitting a paper
• Repeat fixes and reviews of experimental results
• Track unresolved concerns across review rounds

Improve research through repeated Gemini reviews, code changes, experiments, and analysis. The workflow records full feedback and actions, then stops when both the score and readiness criteria are met or the round limit is reached.

• Improving research through repeated external reviews
• Implementing and checking fixes for research weaknesses
• Keeping a complete record of reviews and experiments

Develop a vague research approach into a concrete method proposal through repeated Gemini reviews. Keep the original problem and constraints in focus while specifying implementation details, removing unnecessary components, and outlining the minimum experiments needed to test the claims.

• Turning a vague research approach into a concrete method
• Keeping revisions aligned with the original problem
• Simplifying an overly complex research proposal

Improve an existing LaTeX paper through two rounds of Gemini review, targeted edits, and PDF rebuilding. Check whether claims match the evidence, resolve notation and presentation issues, and retain review logs and PDF versions.

• Review and revise a completed paper draft
• Align claims with supporting evidence
• Resolve notation and explanation inconsistencies

Explore computer architecture and circuit design settings by repeatedly running programs, measuring results, and adjusting parameters. Compare configurations against a baseline, respect design constraints, and receive a report with the best configuration found and the search history.

• Tune cache sizes and processor settings
• Reduce circuit area while meeting timing constraints
• Compare compiler flags for runtime or code size

Turn a rough research approach into a focused plan with concrete implementation details and a small set of validation experiments. Repeated Claude reviews help refine the method while keeping the original problem and resource constraints in view.

• Turning a rough research idea into an implementable method
• Narrowing a proposal to one main contribution
• Choosing minimal experiments to test core claims