# Cell Biology

> Study of cell structure, function, division, signaling, and homeostasis

- Skill: `ffsshhttiikk/cell-biology` (Agent Skill)
- Install (CLI): `npx skillmds@latest add ffsshhttiikk/cell-biology`
- Raw SKILL.md: https://api.skillmd.com/api/skills/ffsshhttiikk/cell-biology/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: ffsshhttiikk (https://skillmd.com/u/ffsshhttiikk)
- Updated: 2026-09-17
- Page: https://skillmd.com/skills/ffsshhttiikk/cell-biology

---


# Cell Biology

## What I Do

Cell biology explores the structure, function, and behavior of cells. I cover cellular organelles, cell cycle regulation, apoptosis, cell signaling, membrane transport, cytoskeleton, and cellular metabolism. I help understand cell physiology, disease mechanisms, and experimental cell biology techniques.

## When to Use Me

- Studying cell cycle and division mechanisms
- Understanding organelle function and dynamics
- Analyzing cell signaling pathways
- Designing cell culture experiments
- Studying apoptosis and cell death
- Investigating membrane transport processes
- Understanding cell-cell and cell-matrix interactions

## Core Concepts

1. **Cell Membrane**: Lipid bilayer, membrane proteins, transport mechanisms
2. **Organelles**: Nucleus, mitochondria, ER, Golgi, lysosomes, peroxisomes
3. **Cell Cycle**: G1, S, G2, M phases, checkpoints, cyclins, CDKs
4. **Cell Division**: Mitosis, meiosis, cytokinesis, spindle assembly
5. **Cell Signaling**: Receptors, second messengers, signal transduction
6. **Apoptosis**: Intrinsic and extrinsic pathways, caspases
7. **Cytoskeleton**: Microtubules, microfilaments, intermediate filaments
8. **Cell Adhesion**: Cadherins, integrins, focal adhesions
9. **Cell Metabolism**: Glycolysis, oxidative phosphorylation, autophagy
10. **Cell Communication**: Gap junctions, paracrine, endocrine signaling

## Code Examples

```python
import numpy as np
from typing import List, Dict, Tuple

class CellCycle:
    def __init__(self, cell_type: str):
        self.cell_type = cell_type
        self.phase_lengths = {
            'G1': 11, 'S': 8, 'G2': 4, 'M': 1
        }

    def calculate_cell_cycle_time(self) -> float:
        return sum(self.phase_lengths.values())

    def check_dna_content(self, dna_content: float) -> Dict:
        g1_content = 2.0  # 2N
        s_content_range = (2.0, 4.0)
        g2_content = 4.0  # 4N
        if dna_content < g1_content + 0.3:
            return {'phase': 'G1', 'checkpoint': 'Restriction point'}
        elif dna_content < g2_content - 0.3:
            return {'phase': 'S', 'checkpoint': 'Intra-S checkpoint'}
        elif dna_content < g2_content + 0.3:
            return {'phase': 'G2', 'checkpoint': 'G2/M checkpoint'}
        else:
            return {'phase': 'M', 'checkpoint': 'Metaphase checkpoint'}

    def predict_proliferation(self, growth_factors: float,
                             contact_inhibition: float) -> float:
        base_proliferation = 1.0
        gf_effect = np.tanh(growth_factors / 10)
        ci_effect = 1 - np.tanh(contact_inhibition / 100)
        return base_proliferation * gf_effect * ci_effect

    def calculate_doubling_time(self, initial_cells: float,
                                final_cells: float,
                                hours: float) -> float:
        doublings = np.log2(final_cells / initial_cells)
        return hours / doublings

class ApoptosisAnalysis:
    def __init__(self, cell_line: str):
        self.cell_line = cell_line

    def analyze_caspase_activity(self, caspase_3: float,
                                 caspase_8: float,
                                 caspase_9: float) -> Dict:
        if caspase_3 > 5 and caspase_9 > 3:
            pathway = 'intrinsic'
        elif caspase_8 > 4 and caspase_3 > 3:
            pathway = 'extrinsic'
        else:
            pathway = 'unknown'
        return {
            'pathway': pathway,
            'executioner_active': caspase_3 > 5,
            'apoptotic_index': (caspase_3 + caspase_9) / 2
        }

    def calculate_apoptosis_percentage(self, annexin_v_pos: float,
                                         pi_neg: float,
                                         total_cells: float) -> Dict:
        early_apoptotic = annexin_v_pos / total_cells * 100
        late_apoptotic = pi_neg / total_cells * 100
        return {
            'early_apoptotic': early_apoptotic,
            'late_apoptotic': late_apoptotic,
            'total_apoptotic': early_apoptotic + late_apoptotic
        }

class MembraneTransport:
    def __init__(self, cell_type: str):
        self.cell_type = cell_type

    def calculate_osmotic_pressure(self, solute_conc: float,
                                   temperature: float = 310) -> float:
        R = 0.0821  # L·atm/(mol·K)
        return solute_conc * R * temperature

    def predict_swelling(self, intracellular: float,
                         extracellular: float,
                         water_permeability: float) -> Dict:
        osmolarity_difference = intracellular - extracellular
        if osmolarity_difference > 0:
            direction = 'swelling'
            rate = water_permeability * osmolarity_difference
        else:
            direction = 'shrinking'
            rate = water_permeability * abs(osmolarity_difference)
        return {'direction': direction, 'rate': rate}

    def active_transport_rate(self, atp_consumed: float,
                             substrate_transported: float,
                             coupling_ratio: float) -> float:
        return atp_consumed * coupling_ratio / substrate_transported

class CellSignaling:
    def __init__(self, pathway: str):
        self.pathway = pathway

    def simulate_receptor_kinetics(self, ligand_conc: float,
                                  kd: float,
                                  receptor_num: int) -> Dict:
        occupancy = (ligand_conc / (kd + ligand_conc)) * receptor_num
        return {
            'receptor_occupancy': occupancy,
            'percent_occupied': occupancy / receptor_num * 100
        }

    def predict_downstream_activation(self, receptor_occupancy: float,
                                      amplification_factor: float,
                                      threshold: float) -> bool:
        signal = receptor_occupancy * amplification_factor
        return signal > threshold

cycle = CellCycle("HeLa")
cycle_time = cycle.calculate_cell_cycle_time()
print(f"Cell cycle time: {cycle_time} hours")
phase = cycle.check_dna_content(3.2)
print(f"Cell cycle phase: {phase['phase']}")
doubling = cycle.calculate_doubling_time(1e4, 8e4, 24)
print(f"Doubling time: {doubling:.1f} hours")
```

## Best Practices

1. Maintain proper cell culture conditions (temperature, CO2, humidity)
2. Use appropriate passage numbers to avoid phenotypic drift
3. Include proper controls in cell-based assays
4. Validate cell line authentication and mycoplasma status
5. Use appropriate transfection/infection methods for gene manipulation
6. Choose appropriate readouts for cell viability assays
7. Account for cell density effects in signaling experiments
8. Use proper sterile technique to prevent contamination
9. Optimize imaging conditions for fluorescent proteins
10. Report all cell culture conditions for reproducibility