@wentorai/research-plugins 1.0.0

package/skills/analysis/wrangling/missing-data-handling/SKILL.md

@@ -0,0 +1,224 @@
+---
+name: missing-data-handling
+description: "Diagnose missing data patterns and apply appropriate imputation strategies"
+metadata:
+  openclaw:
+    emoji: "jigsaw"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["missing value imputation", "missing data handling", "outlier detection", "data cleaning", "multiple imputation"]
+    source: "wentor"
+---
+
+# Missing Data Handling
+
+A skill for diagnosing missing data mechanisms, selecting appropriate imputation strategies, and conducting sensitivity analyses. Covers everything from simple imputation to multiple imputation and modern machine learning approaches.
+
+## Missing Data Mechanisms
+
+### Rubin's Classification
+
+Understanding the mechanism determines the appropriate handling strategy:
+
+| Mechanism | Definition | Example | Implication |
+|-----------|-----------|---------|-------------|
+| MCAR | Missingness unrelated to any variable | Lab sample randomly contaminated | Listwise deletion is unbiased (but loses power) |
+| MAR | Missingness related to observed variables | Higher-income respondents skip income question less | Multiple imputation appropriate |
+| MNAR | Missingness related to the missing value itself | Depressed patients drop out of depression study | Requires sensitivity analysis; no simple fix |
+
+### Diagnosing the Mechanism
+
+```python
+import pandas as pd
+import numpy as np
+from scipy import stats
+
+def diagnose_missing_data(df: pd.DataFrame) -> dict:
+    """
+    Diagnose missing data patterns and mechanism.
+    """
+    n_rows, n_cols = df.shape
+    results = {
+        'total_cells': n_rows * n_cols,
+        'total_missing': df.isnull().sum().sum(),
+        'pct_missing': (df.isnull().sum().sum() / (n_rows * n_cols)) * 100,
+        'by_column': {}
+    }
+
+    for col in df.columns:
+        n_missing = df[col].isnull().sum()
+        pct = n_missing / n_rows * 100
+        results['by_column'][col] = {
+            'n_missing': n_missing,
+            'pct_missing': round(pct, 2)
+        }
+
+    # Little's MCAR test approximation
+    # Compare means of other variables between missing/non-missing groups
+    mcar_tests = {}
+    for col in df.columns:
+        if df[col].isnull().sum() > 0:
+            missing_mask = df[col].isnull()
+            for other_col in df.select_dtypes(include=[np.number]).columns:
+                if other_col != col and df[other_col].isnull().sum() == 0:
+                    group_missing = df.loc[missing_mask, other_col]
+                    group_observed = df.loc[~missing_mask, other_col]
+                    if len(group_missing) > 1 and len(group_observed) > 1:
+                        t_stat, p_val = stats.ttest_ind(group_missing, group_observed)
+                        mcar_tests[f'{col}_vs_{other_col}'] = {
+                            't': round(t_stat, 3),
+                            'p': round(p_val, 4)
+                        }
+
+    significant_diffs = sum(1 for v in mcar_tests.values() if v['p'] < 0.05)
+    results['mcar_assessment'] = (
+        'Likely MCAR' if significant_diffs == 0
+        else f'Likely NOT MCAR ({significant_diffs} significant differences found)'
+    )
+    results['mcar_tests'] = mcar_tests
+
+    return results
+```
+
+## Imputation Methods
+
+### Simple Imputation
+
+```python
+def simple_imputation(df: pd.DataFrame, strategy: str = 'mean') -> pd.DataFrame:
+    """
+    Apply simple imputation strategies.
+
+    Args:
+        strategy: 'mean', 'median', 'mode', 'constant', or 'forward_fill'
+    """
+    imputed = df.copy()
+
+    for col in imputed.columns:
+        if imputed[col].isnull().any():
+            if strategy == 'mean' and np.issubdtype(imputed[col].dtype, np.number):
+                imputed[col].fillna(imputed[col].mean(), inplace=True)
+            elif strategy == 'median' and np.issubdtype(imputed[col].dtype, np.number):
+                imputed[col].fillna(imputed[col].median(), inplace=True)
+            elif strategy == 'mode':
+                imputed[col].fillna(imputed[col].mode()[0], inplace=True)
+            elif strategy == 'forward_fill':
+                imputed[col].ffill(inplace=True)
+
+    return imputed
+```
+
+### Multiple Imputation (MICE)
+
+The gold standard for MAR data:
+
+```python
+from sklearn.experimental import enable_iterative_imputer
+from sklearn.impute import IterativeImputer
+from sklearn.linear_model import BayesianRidge
+
+def multiple_imputation(df: pd.DataFrame, n_imputations: int = 20,
+                         max_iter: int = 50) -> list[pd.DataFrame]:
+    """
+    Perform Multiple Imputation by Chained Equations (MICE).
+
+    Args:
+        df: DataFrame with missing values (numeric columns only)
+        n_imputations: Number of imputed datasets (>=20 recommended)
+        max_iter: Maximum iterations per imputation
+    Returns:
+        List of completed DataFrames
+    """
+    imputed_datasets = []
+
+    for i in range(n_imputations):
+        imputer = IterativeImputer(
+            estimator=BayesianRidge(),
+            max_iter=max_iter,
+            random_state=i,
+            sample_posterior=True  # Important for proper MI
+        )
+        imputed_data = imputer.fit_transform(df)
+        imputed_df = pd.DataFrame(imputed_data, columns=df.columns, index=df.index)
+        imputed_datasets.append(imputed_df)
+
+    return imputed_datasets
+
+
+def pool_mi_results(estimates: list[float], variances: list[float]) -> dict:
+    """
+    Pool results across multiply imputed datasets using Rubin's rules.
+
+    Args:
+        estimates: Parameter estimate from each imputed dataset
+        variances: Variance of estimate from each imputed dataset
+    """
+    m = len(estimates)
+    q_bar = np.mean(estimates)  # Pooled estimate
+    u_bar = np.mean(variances)  # Within-imputation variance
+    b = np.var(estimates, ddof=1)  # Between-imputation variance
+
+    # Total variance
+    total_var = u_bar + (1 + 1/m) * b
+
+    # Degrees of freedom (Barnard-Rubin)
+    lambda_hat = ((1 + 1/m) * b) / total_var
+    df_old = (m - 1) / lambda_hat**2
+
+    se = np.sqrt(total_var)
+    ci = (q_bar - 1.96*se, q_bar + 1.96*se)
+
+    return {
+        'pooled_estimate': q_bar,
+        'pooled_se': se,
+        'ci_95': ci,
+        'fraction_missing_info': lambda_hat,
+        'relative_efficiency': 1 / (1 + lambda_hat/m)
+    }
+```
+
+## Outlier Detection
+
+### Statistical Methods
+
+```python
+def detect_outliers(series: pd.Series, method: str = 'iqr') -> pd.Series:
+    """
+    Detect outliers using specified method.
+
+    Returns boolean mask where True indicates an outlier.
+    """
+    if method == 'iqr':
+        q1 = series.quantile(0.25)
+        q3 = series.quantile(0.75)
+        iqr = q3 - q1
+        lower = q1 - 1.5 * iqr
+        upper = q3 + 1.5 * iqr
+        return (series < lower) | (series > upper)
+
+    elif method == 'zscore':
+        z = np.abs((series - series.mean()) / series.std())
+        return z > 3
+
+    elif method == 'mad':
+        median = series.median()
+        mad = np.median(np.abs(series - median))
+        modified_z = 0.6745 * (series - median) / (mad + 1e-10)
+        return np.abs(modified_z) > 3.5
+
+    else:
+        raise ValueError(f"Unknown method: {method}")
+```
+
+## Reporting Standards
+
+When reporting missing data handling in a paper:
+
+1. Report the amount and pattern of missing data (by variable and overall)
+2. State the assumed mechanism (MCAR/MAR/MNAR) with justification
+3. Describe the imputation method and software used
+4. Report the number of imputations (for MI)
+5. Conduct sensitivity analyses (e.g., compare results from complete-case, single imputation, and multiple imputation)
+6. Report results using Rubin's pooling rules for MI
+
+Never simply delete missing data without justification. Even for MCAR data, listwise deletion reduces statistical power and is rarely the best choice.

package/skills/analysis/wrangling/pandas-data-wrangling/SKILL.md

@@ -0,0 +1,242 @@
+---
+name: pandas-data-wrangling
+description: "Data cleaning, transformation, and exploratory analysis with pandas"
+metadata:
+  openclaw:
+    emoji: "🧹"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["CSV data analyzer", "pandas", "data wrangling", "exploratory data analysis", "missing value imputation"]
+    source: "N/A"
+---
+
+# Pandas Data Wrangling Guide
+
+## Overview
+
+Data wrangling -- the process of cleaning, transforming, and preparing raw data for analysis -- typically consumes 60-80% of a data scientist's time. Pandas is the de facto standard library for tabular data manipulation in Python, and mastering its idioms directly translates to faster, more reliable research workflows.
+
+This guide covers the essential pandas operations that researchers encounter daily: loading heterogeneous data sources, diagnosing data quality issues, handling missing values, reshaping data for analysis, and performing exploratory data analysis (EDA). Each section includes copy-paste code examples designed for real-world research datasets.
+
+Whether you are cleaning survey responses, preprocessing experimental logs, merging datasets from multiple sources, or preparing features for machine learning, the patterns here will save hours of trial and error.
+
+## Loading and Inspecting Data
+
+### Reading Common Formats
+
+```python
+import pandas as pd
+import numpy as np
+
+# CSV with encoding and date parsing
+df = pd.read_csv('data.csv', encoding='utf-8',
+                 parse_dates=['timestamp'],
+                 dtype={'participant_id': str})
+
+# Excel with specific sheet
+df = pd.read_excel('data.xlsx', sheet_name='Experiment1',
+                   header=1)  # Skip first row
+
+# JSON (nested)
+df = pd.json_normalize(json_data, record_path='results',
+                       meta=['experiment_id', 'date'])
+
+# Parquet (fast, columnar)
+df = pd.read_parquet('data.parquet')
+```
+
+### Initial Diagnostics
+
+```python
+# Shape and types
+print(f"Shape: {df.shape}")
+print(df.dtypes)
+print(df.info(memory_usage='deep'))
+
+# Statistical summary
+print(df.describe(include='all'))
+
+# Missing value report
+missing = df.isnull().sum()
+missing_pct = (missing / len(df) * 100).round(1)
+missing_report = pd.DataFrame({
+    'count': missing,
+    'percent': missing_pct
+}).query('count > 0').sort_values('percent', ascending=False)
+print(missing_report)
+
+# Duplicate check
+n_dupes = df.duplicated().sum()
+print(f"Duplicate rows: {n_dupes}")
+```
+
+## Handling Missing Data
+
+### Strategy Decision Tree
+
+| Situation | Strategy | pandas Method |
+|-----------|----------|---------------|
+| < 5% missing, random | Drop rows | `df.dropna()` |
+| Numeric, moderate missing | Mean/median imputation | `df.fillna(df.median())` |
+| Categorical missing | Mode or "Unknown" | `df.fillna('Unknown')` |
+| Time series gaps | Forward/backward fill | `df.ffill()` / `df.bfill()` |
+| Systematic missing | Multiple imputation | `sklearn.impute.IterativeImputer` |
+| Feature > 50% missing | Drop column | `df.drop(columns=[...])` |
+
+### Implementation Examples
+
+```python
+# Conditional imputation
+df['age'] = df['age'].fillna(df.groupby('group')['age'].transform('median'))
+
+# Interpolation for time series
+df['temperature'] = df['temperature'].interpolate(method='time')
+
+# Flag missing values before imputing (preserve information)
+df['salary_missing'] = df['salary'].isnull().astype(int)
+df['salary'] = df['salary'].fillna(df['salary'].median())
+```
+
+## Data Transformation
+
+### Type Conversion and Cleaning
+
+```python
+# String cleaning
+df['name'] = df['name'].str.strip().str.lower()
+df['email'] = df['email'].str.replace(r'\s+', '', regex=True)
+
+# Categorical conversion (saves memory, enables ordering)
+df['education'] = pd.Categorical(
+    df['education'],
+    categories=['high_school', 'bachelors', 'masters', 'phd'],
+    ordered=True
+)
+
+# Numeric extraction from text
+df['value'] = df['text_field'].str.extract(r'(\d+\.?\d*)').astype(float)
+```
+
+### Reshaping Operations
+
+```python
+# Wide to long (unpivot)
+df_long = pd.melt(df,
+    id_vars=['subject_id', 'condition'],
+    value_vars=['score_t1', 'score_t2', 'score_t3'],
+    var_name='timepoint',
+    value_name='score'
+)
+
+# Long to wide (pivot)
+df_wide = df_long.pivot_table(
+    index='subject_id',
+    columns='condition',
+    values='score',
+    aggfunc='mean'
+).reset_index()
+
+# Cross-tabulation
+ct = pd.crosstab(df['group'], df['outcome'],
+                 margins=True, normalize='index')
+```
+
+### Merging and Joining
+
+```python
+# Left join with validation
+merged = pd.merge(
+    experiments, participants,
+    on='participant_id',
+    how='left',
+    validate='many_to_one',  # Catch unexpected duplicates
+    indicator=True           # Shows _merge column
+)
+
+# Check merge quality
+print(merged['_merge'].value_counts())
+```
+
+## Exploratory Data Analysis (EDA)
+
+### Automated EDA Pipeline
+
+```python
+def quick_eda(df, target_col=None):
+    """Run a quick EDA pipeline on a DataFrame."""
+    print(f"=== Shape: {df.shape} ===\n")
+
+    # Numeric columns
+    numeric_cols = df.select_dtypes(include=np.number).columns
+    print(f"Numeric columns ({len(numeric_cols)}):")
+    print(df[numeric_cols].describe().round(2))
+
+    # Categorical columns
+    cat_cols = df.select_dtypes(include=['object', 'category']).columns
+    print(f"\nCategorical columns ({len(cat_cols)}):")
+    for col in cat_cols:
+        n_unique = df[col].nunique()
+        print(f"  {col}: {n_unique} unique values")
+        if n_unique <= 10:
+            print(f"    {df[col].value_counts().to_dict()}")
+
+    # Correlations with target
+    if target_col and target_col in numeric_cols:
+        corr = df[numeric_cols].corr()[target_col].drop(target_col)
+        print(f"\nCorrelations with '{target_col}':")
+        print(corr.sort_values(ascending=False).round(3))
+
+quick_eda(df, target_col='accuracy')
+```
+
+### GroupBy Aggregations
+
+```python
+# Multi-metric summary by group
+summary = df.groupby('method').agg(
+    mean_acc=('accuracy', 'mean'),
+    std_acc=('accuracy', 'std'),
+    median_time=('runtime_sec', 'median'),
+    n_runs=('run_id', 'count')
+).round(3).sort_values('mean_acc', ascending=False)
+
+print(summary.to_markdown())
+```
+
+## Performance Optimization
+
+| Technique | When to Use | Speedup |
+|-----------|-------------|---------|
+| `pd.Categorical` for strings | Repeated string values | 2-10x memory |
+| `.query()` instead of boolean indexing | Complex filters | 1.5-3x |
+| `pd.eval()` for arithmetic | Column arithmetic | 2-5x |
+| Parquet instead of CSV | Large datasets | 5-20x I/O |
+| `df.pipe()` for chaining | Readable pipelines | Clarity |
+
+```python
+# Method chaining with pipe
+result = (
+    df
+    .query('score > 0')
+    .assign(log_score=lambda x: np.log1p(x['score']))
+    .groupby('group')
+    .agg(mean_log=('log_score', 'mean'))
+    .sort_values('mean_log', ascending=False)
+)
+```
+
+## Best Practices
+
+- **Never modify the original DataFrame in place.** Use `.copy()` when creating derived datasets.
+- **Use method chaining for readability.** Pipe operations together instead of creating intermediate variables.
+- **Document your cleaning steps.** Keep a data cleaning log or use a Jupyter notebook with explanations.
+- **Validate after every merge.** Check row counts, null values, and the `_merge` indicator column.
+- **Profile before optimizing.** Use `df.memory_usage(deep=True)` to identify memory bottlenecks.
+- **Save intermediate results as Parquet.** It preserves dtypes and is much faster than CSV.
+
+## References
+
+- [pandas Documentation](https://pandas.pydata.org/docs/) -- Official reference
+- [Python for Data Analysis, 3rd Edition](https://wesmckinney.com/book/) -- Wes McKinney
+- [Effective Pandas](https://store.metasnake.com/effective-pandas-book) -- Matt Harrison
+- [pandas Cookbook](https://github.com/jvns/pandas-cookbook) -- Julia Evans

package/skills/analysis/wrangling/questionnaire-design-guide/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: questionnaire-design-guide
+description: "Questionnaire and survey design with Likert scales and coding"
+metadata:
+  openclaw:
+    emoji: "clipboard"
+    category: "analysis"
+    subcategory: "wrangling"
+    keywords: ["questionnaire design", "survey design", "Likert scale", "data transformation"]
+    source: "wentor-research-plugins"
+---
+
+# Questionnaire Design Guide
+
+Design valid and reliable survey instruments with proper question types, Likert scale construction, response coding, and data preparation for analysis.
+
+## Survey Design Principles
+
+### Question Types
+
+| Type | Example | Best For | Analysis |
+|------|---------|----------|----------|
+| **Likert scale** | "Rate your agreement: 1-5" | Attitudes, perceptions | Ordinal/interval statistics |
+| **Multiple choice** | "Select your field" | Demographics, categories | Frequencies, chi-square |
+| **Ranking** | "Rank these 5 options" | Preferences, priorities | Rank correlations |
+| **Open-ended** | "Describe your experience" | Exploratory, rich data | Qualitative coding |
+| **Matrix/grid** | Multiple items, same scale | Efficient battery of items | Factor analysis, reliability |
+| **Slider/VAS** | 0-100 visual analog scale | Continuous measures | Parametric statistics |
+| **Semantic differential** | "Easy __ __ __ __ __ Difficult" | Bipolar attitudes | Factor analysis |
+
+### The Four C's of Good Questions
+
+1. **Clear**: Avoid jargon, double-barreled questions, and ambiguity
+2. **Concise**: Keep questions short (ideally under 20 words)
+3. **Complete**: Include all relevant response options
+4. **Consistent**: Use the same scale direction and format throughout
+
+## Likert Scale Design
+
+### Scale Points
+
+| Points | Scale Example | Recommended Use |
+|--------|---------------|-----------------|
+| 4-point | Strongly Disagree to Strongly Agree | Forces choice (no neutral), less discriminating |
+| 5-point | SD, D, Neutral, A, SA | Most common, good balance of simplicity and discrimination |
+| 7-point | SD, D, Somewhat D, Neutral, Somewhat A, A, SA | More discriminating, better for experienced respondents |
+| 11-point (0-10) | Not at all to Completely | NPS, continuous-like measures |
+
+### Anchoring Labels
+
+```
+5-Point Agreement Scale:
+1 = Strongly Disagree
+2 = Disagree
+3 = Neither Agree nor Disagree
+4 = Agree
+5 = Strongly Agree
+
+5-Point Frequency Scale:
+1 = Never
+2 = Rarely
+3 = Sometimes
+4 = Often
+5 = Always
+
+5-Point Satisfaction Scale:
+1 = Very Dissatisfied
+2 = Dissatisfied
+3 = Neutral
+4 = Satisfied
+5 = Very Satisfied
+```
+
+### Reverse-Coded Items
+
+Include 2-3 reverse-coded items per construct to detect acquiescence bias:
+
+```
+Regular:  "I find research methods interesting."        (1-5: SD to SA)
+Reversed: "I find research methods tedious and dull."   (1-5: SD to SA)
+
+# Recode reversed items before analysis:
+# reversed_score = (max_scale + 1) - raw_score
+# For a 5-point scale: reversed_score = 6 - raw_score
+```
+
+## Constructing a Multi-Item Scale
+
+### Step-by-Step Process
+
+1. **Define the construct**: Write a clear conceptual definition
+2. **Generate items**: Write 1.5-2x the number of items you plan to keep (e.g., write 15 items for an 8-item scale)
+3. **Expert review**: Have 3-5 experts rate each item for relevance (Content Validity Index)
+4. **Pilot test**: Administer to 30-50 respondents
+5. **Item analysis**: Calculate item-total correlations, check reliability
+6. **Exploratory Factor Analysis (EFA)**: Confirm dimensionality
+7. **Finalize scale**: Remove weak items, re-test reliability
+
+### Example: Research Self-Efficacy Scale
+
+```
+Construct: Belief in one's ability to conduct academic research
+
+Items (5-point Likert, Strongly Disagree to Strongly Agree):
+RSE1: I can formulate clear research questions.
+RSE2: I can design an appropriate research methodology.
+RSE3: I can analyze data using statistical software.
+RSE4: I can write a publishable research paper.
+RSE5: I can critically evaluate published research.
+RSE6: I can present research findings at a conference.
+RSE7R: I struggle to interpret statistical results. [REVERSED]
+RSE8R: I find it difficult to synthesize literature. [REVERSED]
+```
+
+## Data Coding and Preparation
+
+### Coding Scheme
+
+```python
+import pandas as pd
+import numpy as np
+
+# Define coding scheme
+likert_coding = {
+    "Strongly Disagree": 1,
+    "Disagree": 2,
+    "Neither Agree nor Disagree": 3,
+    "Agree": 4,
+    "Strongly Agree": 5
+}
+
+# Apply coding
+df["Q1_coded"] = df["Q1_raw"].map(likert_coding)
+
+# Reverse code specific items
+reverse_items = ["RSE7R", "RSE8R"]
+max_scale = 5
+for item in reverse_items:
+    df[f"{item}_recoded"] = (max_scale + 1) - df[item]
+
+# Calculate composite score (mean of items)
+scale_items = ["RSE1", "RSE2", "RSE3", "RSE4", "RSE5", "RSE6",
+               "RSE7R_recoded", "RSE8R_recoded"]
+df["RSE_mean"] = df[scale_items].mean(axis=1)
+```
+
+### Missing Data Handling
+
+```python
+# Check missing data patterns
+print(df[scale_items].isnull().sum())
+print(f"Complete cases: {df[scale_items].dropna().shape[0]} / {df.shape[0]}")
+
+# Common strategies:
+# 1. Listwise deletion (if < 5% missing)
+df_complete = df.dropna(subset=scale_items)
+
+# 2. Mean imputation per item (simple but biased)
+df[scale_items] = df[scale_items].fillna(df[scale_items].mean())
+
+# 3. Person-mean imputation (if < 20% of items missing per person)
+def person_mean_impute(row, items, max_missing=2):
+    if row[items].isnull().sum() <= max_missing:
+        return row[items].fillna(row[items].mean())
+    return row[items]  # leave as NaN if too many missing
+
+df[scale_items] = df.apply(lambda r: person_mean_impute(r, scale_items), axis=1)
+```
+
+## Reliability Analysis
+
+### Cronbach's Alpha
+
+```python
+import pingouin as pg
+
+# Calculate Cronbach's alpha
+alpha = pg.cronbach_alpha(df[scale_items])
+print(f"Cronbach's alpha: {alpha[0]:.3f}")
+# Interpretation: >= 0.70 acceptable, >= 0.80 good, >= 0.90 excellent
+```
+
+```r
+library(psych)
+
+# Cronbach's alpha with item-level diagnostics
+alpha_result <- alpha(data[, scale_items])
+print(alpha_result)
+# Check "raw_alpha if item dropped" to identify weak items
+```
+
+### Item-Total Correlations
+
+```r
+# Corrected item-total correlations (should be > 0.30)
+item_stats <- alpha_result$item.stats
+print(item_stats[, c("r.drop", "raw.alpha")])
+# r.drop < 0.30: consider removing the item
+# raw.alpha increases if dropped: item is weakening the scale
+```
+
+## Validity Assessment
+
+| Validity Type | Method | Criterion |
+|--------------|--------|-----------|
+| **Content validity** | Expert panel rating (CVI) | I-CVI >= 0.78, S-CVI/Ave >= 0.90 |
+| **Construct validity** | Exploratory Factor Analysis (EFA) | Eigenvalue > 1, loadings > 0.40 |
+| **Convergent validity** | Correlation with related construct | r > 0.30 |
+| **Discriminant validity** | Correlation with unrelated construct | r < 0.30 |
+| **Criterion validity** | Correlation with external criterion | Significant correlation |
+| **Test-retest reliability** | ICC or Pearson r over 2-4 weeks | ICC > 0.70 |
+
+## Common Design Mistakes
+
+| Mistake | Example | Fix |
+|---------|---------|-----|
+| Double-barreled question | "This course is interesting and useful" | Split into two separate items |
+| Leading question | "Don't you agree that X is important?" | "How important is X to you?" |
+| Absolute terms | "Do you always check citations?" | "How often do you check citations?" |
+| Missing option | No "Not Applicable" when needed | Add N/A option or filter logic |
+| Inconsistent scale direction | Some items 1=good, others 1=bad | Standardize direction; clearly mark reversed items |
+| Too many items | 100-item survey | Aim for 5-8 items per construct, 15-30 min total |
+| No pilot test | Skip straight to full deployment | Always pilot with 30-50 respondents |
+
+## Survey Platform Comparison
+
+| Platform | Cost | Features | Best For |
+|----------|------|----------|----------|
+| Qualtrics | Institutional | Advanced logic, panels, API | Large academic studies |
+| SurveyMonkey | Freemium | Easy to use, basic analysis | Quick surveys |
+| Google Forms | Free | Simple, integrates with Sheets | Classroom, pilot testing |
+| LimeSurvey | Free/self-hosted | Open source, full control | Privacy-sensitive research |
+| REDCap | Free (academic) | Clinical data, HIPAA compliant | Medical/clinical research |
+| Prolific | Per-response | Participant recruitment | Online experiments |