This page is about Large Language Models.
Quand je reçois des courriels ou des messages écrits avec l’IA, ça m’énerve un peu. C’est pour ça que je n’utilise pas l’IA pour écrire à ma place. J’écris tout moi-même avec mon ton et mes imperfections. J’utilise les LLM pour critiquer ce que j’écris. Ma technique favorite consiste à demander à un modèle de langage une liste d’experts qui pourraient critiquer mon texte. Chaque expert me donne un point de vue différent sur le texte, que je peux alors clarifier et améliorer en prenant en compte ou non les avis des experts virtuels.
Avante wrote in the AGENTS.md file of one of my projects:
Run lint and typecheck commands (e.g.,
ruff,mypy) after modifications to ensure code quality.
I don’t use ruff or mypy. I use black.
A July 2023 example where GPT4 provides a better answer than Bard. Dropping unique values (suggested by Bard) reduces the data by a lot it is a misleading answer. Resetting the index is the correct answer suggested by GPT4.
Same code and error fed to both GPT 4 and BARd
g = seaborn.relplot(data=harvest_demand, x='year', y='harvest_requested',
col='iso2_code', hue='scenario', kind='line', col_wrap=4,
facet_kws={'sharey': False, 'sharex': False})
g.set_titles(row_template="{row_name}", col_template="{col_name}")
g.fig.set_size_inches(20,15)
g.fig.subplots_adjust(hspace=0.3)
/home/paul/.local/lib/python3.9/site-packages/seaborn/_core.py:1057: FutureWarning: reindexing with a non-unique Index is deprecated and will raise in a future version.
comp_col.loc[orig.index] = pd.to_numeric(axis.convert_units(orig))
ValueError Traceback (most recent call last)
/tmp/ipykernel_58796/3787323421.py in <cell line: 1>()
----> 1 g = seaborn.relplot(data=harvest_demand, x='year', y='harvest_requested',
2 col='iso2_code', hue='scenario', kind='line', col_wrap=4,
3 facet_kws={'sharey': False, 'sharex': False})
4 g.set_titles(row_template="{row_name}", col_template="{col_name}")
5 g.fig.set_size_inches(20,15)
~/.local/lib/python3.9/site-packages/seaborn/_decorators.py in inner_f(*args, **kwargs)
44 )
45 kwargs.update({k: arg for k, arg in zip(sig.parameters, args)})
---> 46 return f(**kwargs)
47 return inner_f
48
~/.local/lib/python3.9/site-packages/seaborn/relational.py in relplot(x, y, hue, size, style, data, row, col, col_wrap, row_order, col_order, palette, hue_order, hue_norm, sizes, size_order, size_norm, markers, dashes, style_order, legend, kind, height, aspect, facet_kws, units, **kwargs)
1034
1035 # Draw the plot
-> 1036 g.map_dataframe(func, **plot_kws)
1037
1038 # Label the axes
~/.local/lib/python3.9/site-packages/seaborn/axisgrid.py in map_dataframe(self, func, *args, **kwargs)
775
776 # Draw the plot
--> 777 self._facet_plot(func, ax, args, kwargs)
778
779 # For axis labels, prefer to use positional args for backcompat
~/.local/lib/python3.9/site-packages/seaborn/axisgrid.py in _facet_plot(self, func, ax, plot_args, plot_kwargs)
804 plot_args = []
805 plot_kwargs["ax"] = ax
--> 806 func(*plot_args, **plot_kwargs)
807
808 # Sort out the supporting information
~/.local/lib/python3.9/site-packages/seaborn/_decorators.py in inner_f(*args, **kwargs)
44 )
45 kwargs.update({k: arg for k, arg in zip(sig.parameters, args)})
---> 46 return f(**kwargs)
47 return inner_f
48
~/.local/lib/python3.9/site-packages/seaborn/relational.py in lineplot(x, y, hue, size, style, data, palette, hue_order, hue_norm, sizes, size_order, size_norm, dashes, markers, style_order, units, estimator, ci, n_boot, seed, sort, err_style, err_kws, legend, ax, **kwargs)
708 p._attach(ax)
709
--> 710 p.plot(ax, kwargs)
711 return ax
712
~/.local/lib/python3.9/site-packages/seaborn/relational.py in plot(self, ax, kws)
469 # Loop over the semantic subsets and add to the plot
470 grouping_vars = "hue", "size", "style"
--> 471 for sub_vars, sub_data in self.iter_data(grouping_vars, from_comp_data=True):
472
473 if self.sort:
~/.local/lib/python3.9/site-packages/seaborn/_core.py in iter_data(self, grouping_vars, reverse, from_comp_data)
981
982 if from_comp_data:
--> 983 data = self.comp_data
984 else:
985 data = self.plot_data
~/.local/lib/python3.9/site-packages/seaborn/_core.py in comp_data(self)
1055 orig = self.plot_data[var].dropna()
1056 comp_col = pd.Series(index=orig.index, dtype=float, name=var)
-> 1057 comp_col.loc[orig.index] = pd.to_numeric(axis.convert_units(orig))
1058
1059 if axis.get_scale() == "log":
~/.local/lib/python3.9/site-packages/pandas/core/indexing.py in __setitem__(self, key, value)
714
715 iloc = self if self.name == "iloc" else self.obj.iloc
--> 716 iloc._setitem_with_indexer(indexer, value, self.name)
717
718 def _validate_key(self, key, axis: int):
~/.local/lib/python3.9/site-packages/pandas/core/indexing.py in _setitem_with_indexer(self, indexer, value, name)
1688 self._setitem_with_indexer_split_path(indexer, value, name)
1689 else:
-> 1690 self._setitem_single_block(indexer, value, name)
1691
1692 def _setitem_with_indexer_split_path(self, indexer, value, name: str):
~/.local/lib/python3.9/site-packages/pandas/core/indexing.py in _setitem_single_block(self, indexer, value, name)
1927 # setting for extensionarrays that store dicts. Need to decide
1928 # if it's worth supporting that.
-> 1929 value = self._align_series(indexer, Series(value))
1930
1931 elif isinstance(value, ABCDataFrame) and name != "iloc":
~/.local/lib/python3.9/site-packages/pandas/core/indexing.py in _align_series(self, indexer, ser, multiindex_indexer)
2089 if obj.ndim == 2 and is_empty_indexer(indexer[0], ser._values):
2090 return ser._values.copy()
-> 2091 ser = ser.reindex(obj.axes[0][indexer[0]], copy=True)._values
2092
2093 # single indexer
~/.local/lib/python3.9/site-packages/pandas/core/series.py in reindex(self, *args, **kwargs)
4670 )
4671 kwargs.update({"index": index})
-> 4672 return super().reindex(**kwargs)
4673
4674 @deprecate_nonkeyword_arguments(version=None, allowed_args=["self", "labels"])
~/.local/lib/python3.9/site-packages/pandas/core/generic.py in reindex(self, *args, **kwargs)
4964
4965 # perform the reindex on the axes
-> 4966 return self._reindex_axes(
4967 axes, level, limit, tolerance, method, fill_value, copy
4968 ).__finalize__(self, method="reindex")
~/.local/lib/python3.9/site-packages/pandas/core/generic.py in _reindex_axes(self, axes, level, limit, tolerance, method, fill_value, copy)
4984
4985 axis = self._get_axis_number(a)
-> 4986 obj = obj._reindex_with_indexers(
4987 {axis: [new_index, indexer]},
4988 fill_value=fill_value,
~/.local/lib/python3.9/site-packages/pandas/core/generic.py in _reindex_with_indexers(self, reindexers, fill_value, copy, allow_dups)
5030
5031 # TODO: speed up on homogeneous DataFrame objects (see _reindex_multi)
-> 5032 new_data = new_data.reindex_indexer(
5033 index,
5034 indexer,
~/.local/lib/python3.9/site-packages/pandas/core/internals/managers.py in reindex_indexer(self, new_axis, indexer, axis, fill_value, allow_dups, copy, consolidate, only_slice, use_na_proxy)
677 # some axes don't allow reindexing with dups
678 if not allow_dups:
--> 679 self.axes[axis]._validate_can_reindex(indexer)
680
681 if axis >= self.ndim:
~/.local/lib/python3.9/site-packages/pandas/core/indexes/base.py in _validate_can_reindex(self, indexer)
4105 # trying to reindex on an axis with duplicates
4106 if not self._index_as_unique and len(indexer):
-> 4107 raise ValueError("cannot reindex on an axis with duplicate labels")
4108
4109 def reindex(
ValueError: cannot reindex on an axis with duplicate labelsBard Reply:
> The error message you are getting is saying that you cannot reindex a
> column
> with duplicate labels. This is because Seaborn is trying to create a new
> Series for each unique value in the iso2_code column, but there are duplicate
> values in this column.
> To fix this error, you need to remove the duplicate values from the
> iso2_code
> column. You can do this using the drop_duplicates() method. For example:
> Pythonharvest_demand = harvest_demand.drop_duplicates(subset=“iso2_code”)
Use code with caution. Learn more
Once you have removed the duplicate values, you should be able to run the relplot() function without any errors.
Here is the full code with the drop_duplicates() method added: Python
import seaborn as sns
harvest_demand = sns.load_dataset("harvest_demand")
harvest_demand = harvest_demand.drop_duplicates(subset="iso2_code")
g = sns.relplot(
data=harvest_demand,
x="year",
y="harvest_requested",
col="iso2_code",
hue="scenario",
kind="line",
col_wrap=4,
facet_kws={"sharey": False, "sharex": False},
)
g.set_titles(row_template="{row_name}", col_template="{col_name}")
g.fig.set_size_inches(20, 15)
g.fig.subplots_adjust(hspace=0.3)Use code with caution. Learn more
This code should now run without any errors.
GPT4 reply:
When x and y are supposed to be the same value but are not necessarily equal. Compare the x and y values on a scatter plot to a 1:1 line.
def comp_plot(df, x_var, y_var, title):
"""Plot comparison for the given data frame"""
# Scatter plot
plt.scatter(df[x_var], df[y_var])
# 1:1 line
line = np.linspace(df[x_var].min(), df[x_var].max(), 100)
plt.plot(line, line, 'r--')
plt.xlabel(f'{x_var} additional text')
plt.ylabel(f'{y_var} additional text')
plt.title(title)
return pltNote on suggestions compared between Bard and Chat GPT-4
# 1:1 line suggested by Bard
line_x = np.linspace(x.min(), x.max(), 100)
line_y = line_x
plt.plot(line_x, line_y, 'r--')
# 1:1 line suggested by GPT4
# Wrong because max(x) is not necessarilty equal to max(y)
# same for min(x) and min(y).
plt.plot([min(x), max(x)], [min(y), max(y)], 'r')Prompt:
Please provide a code example using ISO7064_mod97_10().compute imported from schwifty.checksum.
from schwifty.iban import IBAN
from schwifty.checksum import ISO7064_mod97_10
print(ISO7064_mod97_10().compute(IBAN("DE89370400440532013000").bban))
# 50 Why is this returning 50 although the third and fourth digits are 89 in this IBAN?
Perplexity reply:
> The result is 50 because:
> - The ISO7064_mod97_10().compute() method is calculating a checksum for the
> BBAN (Basic Bank Account Number) part of the IBAN, not the entire IBAN15.
> - The BBAN for this IBAN is "370400440532013000", which doesn't include the
> country code (DE) or the check digits (89).
> - The "89" in the IBAN are actually the check digits for the entire IBAN,
> calculated differently from the BBAN checksum2.
> The IBAN check digits (89) are calculated using the following process:
> - Move the first four characters to the end: "370400440532013000DE89"
> - Convert letters to numbers (D=13, E=14): "370400440532013000131489"
> - Interpret as a decimal integer and compute modulo 97
> - Subtract the result from 98Gemeni reply:
> You're observing the incorrect result (50 instead of 89) because you're
> again providing only the bban (Basic Bank Account Number) to the
> ISO7064_mod97_10().compute method, and not the complete IBAN structure
> needed for the ISO 7064 MOD 97-10 algorithm.
> Here's the corrected code and explanation:
> Python
> from schwifty.iban import IBAN
> from schwifty.checksum import ISO7064_mod97_10
> iban_string = "DE89370400440532013000"
> iban_object = IBAN(iban_string)
> # Correctly pass the country code, check digits, and BBAN as one string
> iban_components = [iban_object.country_code + iban_object.check_digits + iban_object.bban]
> # Compute the check digits
> computed_check_digits = ISO7064_mod97_10().compute(iban_components)
> print(computed_check_digits) # Output: 89
> #validate the iban.
> print(iban_object.is_valid) #output: True
> Explanation of the Correction:
> Correct Input:
> The ISO7064_mod97_10().compute method expects the entire IBAN structure (or at least the parts needed to calculate the check digits).
> Therefore, we correctly create the iban_components list by concatenating the country_code, check_digits, and bban from the IBAN object.
> Algorithm Behavior:
> The ISO 7064 MOD 97-10 algorithm, as implemented in schwifty, performs the necessary rearrangement and numerical conversion of the IBAN string before applying the modulus 97 operation.
> When the correct input is provided, it accurately calculates the check digits, which are "89" in this case.
> Why Your Original Code Failed:
> By providing only the bban, you were giving the algorithm incomplete data. The algorithm then proceeded to perform calculations on this incomplete data, resulting in the incorrect "50".
> It is very important to remember that the ISO 7064 MOD 97-10 algorithm
> works on the entire IBAN structure.The LLM answers and suggestions are wrong. The problem is that the input should be a list with BBAN first and then country code as such:
from schwifty.checksum import ISO7064_mod97_10
iban_de = IBAN("DE89370400440532013000")
print("Checksum: ", ISO7064_mod97_10().compute([iban_de.bban, iban_de.country_code]))
# Checksum: 89
Formulated directly without using an IBAN object:
print("Checksum: ", ISO7064_mod97_10().compute(["370400440532013000",
"DE"]))
# Checksum: 89Claude Hallucinating a wrong model version
head docs/ai_generated/notes.md ⎿ # Notes generated for a report
*AI-generated document. Generated 2026-04-17 using Claude Opus via multi-agent synthesis.*Paul prompt:
❯ I used Sonnet, why does the document state that it was using Claude Opus? Is
it possible that it switched model for the multi agent part? or is this rather
a hallucination? This doucment was made in a previous session today, do you
ahve the possibility to invenstigate what model was used?Claude:
● Let me check the git history for that file and read it for more context.
● Bash(git log –oneline – docs/ai_generated/framing_the_cbm_timba_feedback_loop.md) ⎿ 8fa5785 AI generated exploration of the framing question
● Bash(git show 8fa5785 –stat) ⎿ commit 8fa578556e04ce3832d42543b9f28c13babc0b11 Author: Paul Rougieux paul.rougieux@gmail.com Date: Fri Apr 17 10:48:15 2026 +0200 … +5 lines (ctrl+o to expand)
● I can’t access previous session transcripts — each conversation starts fresh with no memory of prior sessions.
On the “Claude Opus” claim: it’s most likely a hallucination. Claude models don’t reliably know which specific model variant they are — when asked or when writing self-referential metadata, they often guess or fabricate. The carbon-budget-modelling or forest-sector-analysis skills can spawn sub-agents, and those can be configured with a specific model override, but whether Opus was actually used isn’t recoverable from this file alone.
The git commit doesn’t record model metadata. If you want future documents to accurately reflect the model, the safest approach is to inject the model name at write-time from outside the model (e.g., via a hook or a wrapper script that appends it).
“Tree-structured, shareable history Sessions are stored as trees. Use /tree to navigate to any previous point and continue from there. All branches live in a single file. Filter by message type, label entries as bookmarks. Export to HTML with /export, or upload to a GitHub gist with /share and get a shareable URL that renders it.”
Install
curl -fsSL https://pi.dev/install.sh | sh
Claude
Eden AI isn’t a built-in Pi provider
There’s no /login entry or EDEN_AI_API_KEY variable for it. But Eden AI exposes an OpenAI-compatible chat-completions endpoint, and Pi supports exactly that case through a custom provider in ~/.pi/agent/models.json (using api: “openai-completions”).
See also bookmark document.
https://x.com/TawohAwa/status/2055621573466534132
- The Task Paralysis Shatterer
Prompt: “I am staring at [Task] and can’t start. Break this down into ‘Ridiculously Small’ steps that take less than 1 minute each. Give me the first step and tell me exactly where to put my hands to begin.”
- The Dopamine Menu Architect
Prompt: “I am feeling under-stimulated. Create a ‘Dopamine Menu’ for me with 5-minute ‘Appetizers’ (quick movement), 20-minute ‘Entrees’ (deep work), and 10-minute ‘Sides’ (creative play) to keep my brain engaged.”
- The “Body Doubling” Simulator
Prompt: “Act as my virtual body double for the next 30 minutes. I will tell you what I’m working on, and I want you to check in every 10 minutes to ask for a status update and keep my focus anchored.”
- The Context-Switching Guide
Prompt: “I just finished [Task A] and need to start [Task B], but my brain is stuck. Design a 3-minute ‘Mental Palate Cleanser’ routine to help me transition between these two different types of energy.”
- The Interest-Based Filter
Prompt: “I have a boring administrative task: [Task]. Help me gamify this by connecting it to my current hyper-fixation: [Interest]. Create a ‘Quest’ structure where finishing the task unlocks a reward.”
- The Time-Blindness Auditor
Prompt: “I think [Project] will take 20 minutes, but it usually takes 2 hours. Help me ‘Time-Map’ this by identifying the 3 hidden sub-tasks I always forget to account for so I can set a realistic deadline.”
- The Executive Function Externalizer
Prompt: “My brain is full of ‘Open Loops.’ I will dump everything I’m worried about below. Categorize these into ‘Now,’ ‘Later,’ and ‘Trash,’ and then write a 1-sentence ‘Actionable Next Step’ for only the ‘Now’ items.”
Awa K. Penn @TawohAwa · Credit to AIcreatorTyler
Claude:
Output contracts (emerging as a 2025-2026 best practice) — Treating the prompt as a specification: what you want, what information the model may use, what it must not do, the exact output shape, and how the result will be checked. One framing: “Most bad model outputs are actually bad acceptance criteria.” This is definitional pressure applied to the exit condition.
Success criteria prompting — The recommended format is now explicit:
Goal: {{one sentence}} Success criteria: - {{must-have 1}} - {{must-have 2}} - {{must-not-do}}
The insight from the literature: “When you say ‘improve this,’ you’re outsourcing the definition of ‘improve’ to the model, and the model will default to generic optimization goals.” That’s definitional pressure stated plainly.
The comment task could be simply commenting on an idea, it could reviewing a draft document, or it could be analysing the feasibility of a project proposal from multiple discipline: technical feasibility, legal issues, time constraints etc.
Given a paragraph of text describing a topic or issue. Ask the LLM:
what experts could comment on that topic.
Review the list of suggest experts, remove some or ask for more experts if you want. Then ask :
For each expert create a parallel agent that will comment on that topic in separate markdown files.
Given this dataset suggest a list of experts which would provide data visualisation.
For each expert start a parallel agent and generate python script that create the visualization. Place the scripts and plots in a plots directory, ignore the plot images in gitignore, only the script will be saved in git.
Option: add a reference publication or report to help explore potential experts relevant to the topic.
Use this prompt to find out which real world person made it into the training data:
who is <name of person> in your weights? list skills and literature without going online.For example well known researchers in my domain
who is Christian Breyer in your weights? list skills and literature without going online.
who is Joseph Buongiorno in your weights? list skills and literature without going online.“Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
Ask the questions one at a time.
If a question can be answered by exploring the codebase, explore the codebase instead.”
Techniques to review scientific papers with the help of LLMs.
For example an LLM trick is to start your Gemeni, Claude or even ChatGPT prompts with the following sentence, then paste a paragraph from your paper.
“Provide a list of personas that would criticize this paragraph in a scientific paper: [Paste paragraph here]”
You will continue to write the article yourself, but this will provide useful feedback. In my experience, Gemeni is great at this exercice because it directly provides a short paragraph with the perspective of the different personas.
Another trick is to ask the generative model what is redundant and what can be removed from a paragraph.
“To make it shorter tell me what is redundant and can be removed: [Paste paragraph here]”
Issues with asking LLMs to review scientific papers:
Skill atrophy: learning to summarize is a skill that improves when practicing.
Intellectual property issue: pasting an unpublished paper in a commercial LLM is leaking important intellectual property.
Paul simple prompt:
%>% Suggest a hostile but competent reviewer to critique paper/paper.md. Then provide a review.
Inspired by a more complex prompt seen at “how NOT to review a paper The tools and techniques of the adversarial reviewer” https://sigmodrecord.org/publications/sigmodRecord/0812/p100.open.cormode.pdf
Number 18. the “Domain‑Expert Hostile Review Simulation” Prompt
Role: Simulate a hostile but competent domain expert reviewing this paper for a top‑tier venue. Task:
Briefly describe the reviewer’s background (field, methods, typical objections).
Write a full, critical review including:
Summary of contributions.
Major concerns.
Minor comments.
Overall recommendation (accept/weak accept/weak reject/reject) with justification.
Then, switch roles to “Author Response Coach” and for each major concern, outline how the authors could either:
Pre‑emptively revise the manuscript, or
Prepare a strong rebuttal argument. Keep the bar high, as for a selective journal/conference.
Manuscript: [PASTE TEXT]
Prompt to generate reviewing techniques: https://gemini.google.com/share/0a0ce8aa192f
I am a researcher looking to optimize my scientific writing process using LLMs. Act as an Expert Scientific Editor and AI Prompt Engineer.
Provide a comprehensive list of advanced ‘adversarial’ and ‘structural’ techniques for reviewing a scientific paper. For each technique, provide:
The Name of the Technique.
The Specific Prompt to use.
The Goal (e.g., finding logical gaps, testing the strength of the pothesis, or improving citation flow).
A ‘Stress Test’ Persona: Describe a specific type of reviewer (e.g., ‘The Statistical Hawk’ or ‘The Scope Enforcer’) that this technique helps satisfy.
Focus on techniques that go beyond simple proofreading, such as checking for ‘Claim-Evidence Mismatch’ or ‘Predicting Reviewer Rebuttals’.
Perplexity provides a vast list of 18 suggestions based on thae meta prompt https://www.perplexity.ai/search/i-am-a-researcher-looking-to-o-4ryLUEKbQMORSFnYQnQuVQ#0
It links to this text “how NOT to review a paper The tools and techniques of the adversarial reviewer” https://sigmodrecord.org/publications/sigmodRecord/0812/p100.open.cormode.pdf
https://x.com/alex_prompter/status/2074584979057868901?s=20
Before writing a single line in a new code base, Thariq asks Fable to surface what he doesn’t know. “I’m working on a new auth provider that I know nothing about in this code base. Can you do a blind spot pass to help me figure out my relevant unknown unknowns and help me prompt better?” That single technique eliminates hours of debugging from bad assumptions.
https://x.com/alex_prompter/status/2074584979057868901?s=20
“Prioritize questions that would change the architecture”
Inspired by Karpathy https://x.com/techNmak/status/2043683120319520806?s=20
Andrej Karpathy wrote something that every Claude Code user has felt but couldn’t articulate.
Three quotes. Read them slowly.
“The models make wrong assumptions on your behalf and just run along with them without checking. They don’t manage their confusion, don’t seek clarifications, don’t surface inconsistencies, don’t present tradeoffs, don’t push back when they should.”
“They really like to overcomplicate code and APIs, bloat abstractions, don’t clean up dead code… implement a bloated construction over 1000 lines when 100 would do.”
“They still sometimes change/remove comments and code they don’t sufficiently understand as side effects, even if orthogonal to the task.”
You’ve seen all three. Probably this week.
Someone turned these three observations into a single CLAUDE[.]md file. Four principles, one install, directly addresses each quote:
1./ Think before coding Don’t assume. Don’t hide confusion. State ambiguity explicitly. Present multiple interpretations rather than silently picking one. Push back if a simpler approach exists. Stop and ask rather than guess.
2./ Simplicity first No features beyond what was asked. No abstractions for single-use code. No “flexibility” that wasn’t requested. No error handling for impossible scenarios. The test: would a senior engineer say this is overcomplicated? If yes, rewrite it.
3./ Surgical changes Don’t “improve” adjacent code. Don’t refactor things that aren’t broken. Match the existing style even if you’d do it differently. If you notice unrelated dead code, mention it, don’t delete it. Every changed line should trace directly to the request.
4./ Goal-driven execution Transform “fix the bug” into “write a test that reproduces it, then make it pass.” Transform “add validation” into “write tests for invalid inputs, then make them pass.” Give it success criteria and watch it loop until done.
This last one is Karpathy’s key insight captured directly: “LLMs are exceptionally good at looping until they meet specific goals… Don’t tell it what to do, give it success criteria and watch it go.”
Good tests are integration-style https://github.com/mattpocock/skills/blob/main/tdd/SKILL.md
Philosophy
Core principle: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn’t.
Good tests are integration-style: they exercise real code paths through public APIs. They describe what the system does, not how it does it. A good test reads like a specification - “user can checkout with valid cart” tells you exactly what capability exists. These tests survive refactors because they don’t care about internal structure.
Bad tests are coupled to implementation. They mock internal collaborators, test private methods, or verify through external means (like querying a database directly instead of using the interface). The warning sign: your test breaks when you refactor, but behavior hasn’t changed. If you rename an internal function and tests fail, those tests were testing implementation, not behavior.
Anti-Pattern: Horizontal Slices
DO NOT write all tests first, then all implementation. This is “horizontal slicing” - treating RED as “write all tests” and GREEN as “write all code.”
This produces crap tests:
Tests written in bulk test imagined behavior, not actual behavior You end up testing the shape of things (data structures, function signatures) rather than user-facing behavior Tests become insensitive to real changes - they pass when behavior breaks, fail when behavior is fine You outrun your headlights, committing to test structure before understanding the implementationCorrect approach: Vertical slices via tracer bullets. One test → one implementation → repeat. Each test responds to what you learned from the previous cycle. Because you just wrote the code, you know exactly what behavior matters and how to verify it.
It is similar to the expert panel technique that I have been using before. You ask the LLM to expand the description of a topic from multiple experts taking different perspectives in a detailed document. That helps surface contradictions, then you have a coordinating agent summarise the output.
Here is what I added on top as Claude prompt
In the ai_generated sub directory create a new subdirectory called storm.
We will use the storm stanford method with parallel experts to analyse the
following issue: [pasted text]
A coordinating agent should run the following 4 prompts to sub agents the
first prompt should also itself spawn sub agents.the practitioner: what do they know that academics miss? the skeptic: what’s the strongest counterargument? the economist: who profits from the current narrative? the historian: what pattern has played out before? the academic: what does the evidence actually say?
Prompt 1, The Multi Perspective Scan
I need to research [YOUR TOPIC].
Simulate 5 different expert perspectives on this topic:
1. THE PRACTITIONER: works with this daily.
What do they know that academics miss?
What practical realities are usually ignored?
2. THE ACADEMIC: has studied this for years.
What does the peer reviewed evidence actually say?
Where does the evidence contradict popular belief?
3. THE SKEPTIC: thinks the mainstream view is wrong.
What is the strongest counterargument?
What evidence do proponents conveniently ignore?
4. THE ECONOMIST: follows the money.
Who profits from the current narrative?
What financial incentives shape the research?
5. THE HISTORIAN: has seen similar patterns before.
What historical parallels exist?
What can we learn from how those played out?
For each perspective give me:
- Their core position in 2 sentences
- The strongest evidence supporting their view
- The one thing they would tell me that no other perspective wouldPrompt 2, The Contradiction Map
Based on the 5 perspectives above, map the contradictions:
1. Where do two or more perspectives directly contradict
each other? List each conflict with the specific claims
that clash.
2. Which perspective has the strongest evidence?
Which has the weakest? Why?
3. What is the one question that, if answered, would
resolve the biggest contradiction?
4. What does EVERY perspective agree on?
(This is likely true. Even opponents confirm it.)
5. What topic did NONE of the perspectives address?
(This is the blind spot in the whole field.
Often the most valuable finding.)The is an illustration which says: “The fights are where insights live”
Prompt 3, The Synthesis
Synthesize everything from the 5 perspectives and the
contradiction map into a research briefing:
1. THE ONE PARAGRAPH SUMMARY: explain this topic as if
briefing a CEO who has 60 seconds and needs nuance,
not just the headline.
2. THE 5 KEY FINDINGS: most important things I now know,
ranked by reliability. For each, note which perspectives
support it and which challenge it.
3. THE HIDDEN CONNECTION: one non obvious link between
findings that only shows up when you look at all 5
perspectives together.
4. THE ACTIONABLE INSIGHT: based on all the evidence,
what should someone in [YOUR ROLE] actually DO
differently? Be specific.
5. THE FRONTIER QUESTION: the one question that, if
answered, would change everything about how we
understand this topic.Prompt 4, The Peer Review
“STORM has one known weakness. Stanford’s own researchers flagged it. The system does not self critique. Source bias and fact misassociation sneak in. This prompt fixes that by making Claude grade its own work.”
Now peer review your own research briefing:
1. CONFIDENCE SCORES: rate each of the 5 key findings
on a 1 to 10 scale for reliability. Explain each score.
2. WEAKEST LINK: which claim are you least confident in?
What specific info would you need to verify it?
3. BIAS CHECK: which perspective might be overrepresented
in your synthesis? Did one voice dominate?
4. MISSING PERSPECTIVE: is there a 6th angle I should
have included that would change the conclusions?
5. OVERALL GRADE: if a Stanford professor reviewed this
briefing, what grade would they give and why?
What would they tell me to fix?Claude:
> "Tip: Ask Claude to create a todo list when working on complex tasks to
> track progress and remain on track"10 prompts that have transformed my day-to-day life and that could do the same for https://x.com/oliviscusAI/status/2037118654811156781?s=20
- The Brain Dump Synthesizer
“I am feeling completely overwhelmed by everything I need to do. I am going to brain-dump every thought, task, and anxiety I have below. Please act as a highly organized executive assistant. Read my dump and categorize it into:
- Urgent & Important (Do today),
- Important but not Urgent (Schedule),
- Quick wins (Takes <5 mins), and
- Things I need to let go of or delegate.
Here is my brain dump: [Insert messy thoughts]”
- The Bias-Breaking Decision Engine
“I am trying to make a difficult decision about [insert decision]. My current leanings are [insert current thoughts], but I am worried I have blind spots. Please act as a rational, objective advisor.
Do not just agree with me. Build a ‘steel man’ argument for the opposite choice, outline the secondary and tertiary consequences of my current leaning, and ask me 3 tough questions I haven’t considered.”
- The Feynman Technique Learner
“I need to understand [insert complex topic] but I have zero background in it. Break it down for me using the Feynman Technique. Explain it as if I am a smart high schooler. Use a highly relatable, everyday analogy to explain the core mechanism.
Then, test my understanding by asking me to explain the most difficult part back to you.”
- The High-Stakes Communication Coach
“I need to send an email to [Boss/Client/Partner] regarding [difficult topic/bad news]. I want to sound firm but empathetic, and I want to avoid sounding defensive. Here is my rough, emotional draft: [Insert draft].
Please rewrite this to be professional, emotionally intelligent, and solution-oriented. Tell me exactly what tone changes you made and why.”
- The “80/20” Action Planner
“I want to achieve [insert goal] in the next [timeframe]. Apply the Pareto Principle (80/20 rule) to this goal. Identify the 20% of actions that will drive 80% of the results.
Create a step-by-step execution plan focusing only on those highest-leverage activities, and tell me which common traps I should completely ignore.”
- The Habit Friction Finder
“I have been trying to build the habit of [insert habit] but I keep failing after a few days. Walk me through a ‘friction analysis’. Ask me questions one by one about my environment, routine, and triggers to help me identify the hidden friction points preventing me from doing this.
Then, help me design an environment where failing is harder than succeeding.”
- The Personal “Red Team” for Ideas
“I have an idea for a [business/project/strategy]. The core concept is [explain concept]. Act as a ‘Red Team’ whose only goal is to find the fatal flaws in this idea. Critique the market viability, potential execution bottlenecks, and financial assumptions. Be ruthlessly honest. Don’t sugarcoat it.
Then, suggest one pivot that might solve your biggest critique.”
- The Perspective Shifter
“I am having a conflict with [person/role] about [topic]. I feel [your emotions/stance]. I need you to roleplay as the other person. Based on the context provided, explain to me what their underlying fears, motivations, and logical justifications might be.
Help me see the situation entirely from their side.”
- The Non-Fiction Book Distiller
“Act as a world-class book summarizer. I want to understand the core thesis of [Book Title] by [Author]. Do not just give me a generic summary.
Give me:
- The core thesis in one sentence.
- The 3 most counter-intuitive insights from the book. 3. Three actionable frameworks I can apply to my [Work/Life] immediately based on the book.”
- The Weekly Review Architect
“I want to conduct a weekly review to prepare for Monday. Ask me 5 reflective questions, one at a time, to help me analyze what went well last week, what drained my energy, and what my single ‘frog’ (hardest task) is for the upcoming week.
Wait for my answer to each question before asking the next, and finally summarize my plan for the week.”
https://x.com/eng_khairallah1/status/2043980058378002592
I spent 6 months testing prompts daily. These 25 are the only ones I still use. Save this :) Most prompt lists are full of gimmicks. “Act as a pirate and explain quantum physics.” Cool party trick. Zero practical value. These are different. Every prompt on this list solves a real problem that costs you real time every single week. Copy them. Paste them. Get your hours back. Writing & Content (1-7)
- The First Draft Killer I need a first draft of [TYPE: blog post / newsletter / article] about [TOPIC].
Audience: [WHO THEY ARE] Tone: [SPECIFIC TONE — e.g., direct and slightly irreverent] Length: [WORD COUNT] Does NOT sound like: generic AI, corporate jargon, LinkedIn influencer Does NOT include: filler phrases, unnecessary caveats, “in today’s fast-paced world”
Here is an example of my writing style: [PASTE YOUR BEST PREVIOUS PIECE]
Match the voice and energy of the example. Write a complete first draft. Why it works: The negative constraints kill the AI smell. The example teaches Claude your voice better than any description ever could. This single prompt replaced 90 minutes of staring at a blank page.
- The Thread Expander Turn this idea into a 10-post X/Twitter thread:
[PASTE YOUR IDEA OR HOT TAKE]
Rules:
- Post 1 must be a hook that creates curiosity or makes a bold claim
- Each post should be 1-3 sentences max
- Include specific examples and numbers, not vague claims
- Post 10 must include a clear call to action
- No hashtags. No emojis unless absolutely necessary
- Does NOT sound like: a motivational speaker or LinkedIn guru Why it works: The structure constraint forces a logical narrative. The negative constraints keep it from sounding like every other AI thread on the timeline.
- The Content Repurposer I have one piece of long-form content. Repurpose it into multiple formats.
Original content: [PASTE YOUR ARTICLE / NEWSLETTER / TRANSCRIPT]
Create:
- 5 standalone tweets (each should work on its own, not just be a quote from the article)
- 2 LinkedIn posts (professional but not boring, max 200 words each)
- 3 Instagram caption options (casual, conversational, under 150 words)
- 1 email teaser to drive traffic to the original piece (under 100 words, curiosity-driven subject line)
Keep my voice consistent across all formats. Adapt length and tone to each platform but the core message stays the same. Why it works: One hour of writing becomes an entire week of content across 4 platforms. The “standalone” instruction prevents lazy extraction where every tweet is just a sentence ripped from the article.
- The Headline Machine Generate 20 headline variations for this topic: [TOPIC]
Use these frameworks (at least 2 headlines per framework):
- Curiosity gap: “Why X does Y (and what it means for Z)”
- Specific numbers: “7 ways to…” or “I tested 200 tools and…”
- How-to: “How to X without Y”
- Contrarian: “X is wrong. Here’s why.”
- Social proof: “How I / we achieved X”
- “I want to” format: “I want to [aspirational goal] (full course)”
Rank your top 5 picks and explain why each one would stop someone mid-scroll. Why it works: Most people write one headline and hope for the best. This generates 20 options across proven frameworks and forces Claude to evaluate which ones are actually scroll-stopping.
- The Email Sequence Writer Write a 5-email welcome sequence for [PRODUCT/SERVICE].
Target audience: [WHO] Main pain point: [THEIR BIGGEST PROBLEM] Goal of the sequence: [WHAT YOU WANT THEM TO DO BY EMAIL 5]
For each email provide:
- Subject line (under 50 characters, curiosity-driven)
- Preview text (under 90 characters)
- Body (under 200 words, conversational, one clear CTA)
- Send timing (days after signup)
- A/B subject line variation
Rules:
- Email 1 delivers immediate value, no selling
- Email 2 tells a story that connects to their pain point
- Email 3 introduces the solution subtly
- Email 4 provides social proof or a case study
- Email 5 makes the direct ask with urgency
> Each email should feel like it came from a person, not a marketing
> department. Why it works: This single prompt replaces what a copywriter
> charges \$500 to \$2,000 to produce. The structure ensures each email serves
> a strategic purpose rather than just filling an inbox.
> 06. The SEO Content Brief Create a complete content brief for a blog post
> targeting the keyword: [KEYWORD]Include:
- Recommended title (include target keyword naturally)
- Meta description (under 155 characters, includes keyword)
- Suggested URL slug
- Target word count
- Article outline with H2 and H3 headings
- 5 related keywords to include naturally throughout
- 3 internal linking opportunities (suggest anchor text and where to link)
- 2 external source suggestions for credibility
- Featured snippet opportunity (format the section most likely to win a snippet)
The brief should be detailed enough that any writer could produce the article without additional research. Why it works: This turns a 2-hour research and planning session into a 2-minute prompt. The featured snippet section alone is worth the effort because most writers never optimize for it.
- The Voice Cloner Analyze the following writing samples and extract my writing voice:
[PASTE 2-3 OF YOUR BEST PIECES]
Create a “Voice Profile” that includes:
- Sentence length patterns (short, medium, long, or mixed)
- Vocabulary level (simple, technical, academic)
- Tone qualities (list 5 adjectives)
- Structural habits (paragraph length, use of subheadings, lists vs prose)
- Phrases or patterns I use frequently
- Things I never do (formal vs casual markers)
- Energy level (calm, intense, urgent, conversational)
Then write a 200-word sample paragraph about [ANY TOPIC] using this exact voice profile. I will compare it to my actual writing to verify accuracy. Why it works: Run this once and save the output as a context file. Every future prompt gets your voice right the first time instead of sounding like every other AI output on the internet. Research & Analysis (8-14) 🔍
- The Meeting Prep Brief I have a meeting with [PERSON NAME] from [COMPANY] in [TIME].
Research and create a one-page brief covering:
- Their background (role, career highlights, relevant experience)
- Their company (what they do, recent news, current challenges)
- Any recent public statements, articles, or social posts from them
- 3 talking points that would be relevant to our meeting topic: [TOPIC]
- 3 smart questions to ask them
- 1 potential common ground or shared interest to build rapport
Format as a scannable document I can read in 5 minutes before the call. Why it works: This replaced 30 minutes of LinkedIn stalking and Google searching before every meeting. The “common ground” section alone has opened more doors than any other prep step.
- The Decision Matrix I need to make a decision about [DECISION].
My options are:
- [OPTION A]
- [OPTION B]
- [OPTION C — optional]
My priorities (ranked):
- [MOST IMPORTANT FACTOR]
- [SECOND MOST IMPORTANT]
- [THIRD MOST IMPORTANT]
For each option:
- Score it 1-10 on each priority factor
- List the top 2 risks
- List the top 2 advantages
- Identify what I would need to be true for this option to be the best choice
Then give me your recommended option with reasoning in 3 sentences.
Do NOT hedge. Pick one and defend it. Why it works: The “do not hedge” instruction is everything. Without it, Claude gives you a balanced analysis that helps nobody. With it, you get a clear recommendation you can either follow or argue against.
- The Competitor Breakdown Analyze [COMPETITOR NAME / URL] as if you were a competitive intelligence analyst.
Cover:
- What they sell and to whom (be specific about segments)
- Their pricing model and approximate price points
- Their positioning (how they describe themselves vs how the market sees them)
- Their strongest feature or differentiator
- Their biggest weakness or gap
- Recent moves (product launches, hires, partnerships, funding)
- What they do better than us: [YOUR COMPANY/PRODUCT]
- What we do better than them
End with: 3 strategic opportunities we could exploit based on their weaknesses.
Use only factual information. If you are not confident about a claim, flag it as unverified. Why it works: This replaces a full afternoon of competitive research. The “flag as unverified” instruction prevents Claude from confidently making things up about your competitors, which is the default failure mode.
- The Book Processor I just read [BOOK TITLE] by [AUTHOR].
Create a structured summary with these sections:
- Core thesis (3 sentences max)
- The 5 most important ideas (2-3 sentences each, in my own words not the author’s)
- The strongest argument the author makes (and why it is strong)
- The weakest argument the author makes (and why it is weak)
- 3 specific ways I can apply this to [MY WORK / MY BUSINESS / MY LIFE]
- Key quotes worth saving (max 5)
- Who should read this and who should skip it
Write as if you are briefing a busy executive who wants the signal, not the story. Why it works: This turns a 6-hour book into a 10-minute actionable brief. The “apply this to my specific situation” section makes it practical instead of theoretical.
- The Data Explainer Here is a dataset:
[PASTE YOUR DATA OR DESCRIBE IT]
Analyze it and give me:
- The 3 most important trends (with specific numbers)
- Any anomalies or outliers that are worth investigating
- Correlations between variables (if any exist)
- What this data suggests we should do next (2-3 recommendations)
- What this data does NOT tell us (limitations and blind spots)
Present the findings in two formats:
- A 3-sentence executive summary for someone who has 30 seconds
- A detailed breakdown for someone who has 5 minutes
If the data is insufficient to draw any conclusion, say so rather than speculating. Why it works: The two-format output is the secret. You get the quick answer for yourself and the detailed version for the stakeholder who asks follow-up questions. The “what this data does NOT tell us” section prevents overconfident decisions.
- The Process Documenter I am going to describe a process I do regularly. Turn it into a structured Standard Operating Procedure.
My process: [DESCRIBE WHAT YOU DO IN CASUAL LANGUAGE — e.g., “Every Monday I check our analytics, pull the numbers into a spreadsheet, compare week over week, flag anything weird, and write a summary for the team”]
Create an SOP with:
- Purpose (one sentence — why this process exists)
- Frequency (how often it runs)
- Prerequisites (what needs to be in place before starting)
- Step-by-step procedure (numbered, specific, no ambiguity)
- Quality checks (how to verify each step was done correctly)
- Common mistakes to avoid
- Time estimate for completion
Format it so that a new hire could follow it on their first day without asking any questions. Why it works: Everyone has processes living in their head that they have never documented. This prompt extracts them in a format that can be delegated to a human or automated with an AI agent.
- The Assumption Destroyer I am planning to [PROJECT / DECISION / STRATEGY].
Here are my assumptions:
- [ASSUMPTION 1]
- [ASSUMPTION 2]
- [ASSUMPTION 3]
For each assumption:
- Rate how confident I should be (high / medium / low) and why
- Identify what would need to be true for this assumption to hold
- Describe the worst case scenario if this assumption is wrong
- Suggest one quick way to validate or invalidate it before committing
Then identify 2 assumptions I am probably making that I did NOT list. Explain each one.
Be honest and direct. Do not soften bad news. Why it works: This is the most underrated prompt on the list. The hidden assumptions section has single-handedly prevented bad decisions for me more than once. We are all blind to our own blind spots. Productivity & Business (15-21) ⚡
- The Weekly Review Engine Here is what happened this week:
Completed: [LIST WHAT YOU FINISHED] In progress: [LIST WHAT IS ONGOING] Blocked: [LIST WHAT IS STUCK AND WHY] Wins: [LIST ANY WINS OR MILESTONES]
Based on this:
- What was my highest-impact activity this week?
- What activity consumed time but produced no meaningful result?
- What pattern do you see in my blockers?
- What should I prioritize next week (top 3 only)?
- What should I stop doing or delegate?
Be direct. If something I spent time on was a waste, say so. Why it works: Friday review in 5 minutes instead of 30. The “be direct” instruction prevents Claude from praising everything you did and actually forces useful self-assessment.
- The Client Proposal Generator Draft a project proposal for [CLIENT NAME].
Project: [WHAT YOU ARE BUILDING / PROVIDING] Client’s main problem: [WHAT THEY TOLD YOU THEY NEED] Timeline: [ESTIMATED TIMELINE] Budget range: [YOUR PRICE RANGE]
Structure:
- Understanding of the problem (show them you listened — 3 sentences)
- Proposed solution (what you will build / deliver)
- Scope (what is included and explicitly what is NOT included)
- Timeline with milestones
- Investment (pricing with payment schedule)
- What happens next (clear next step and CTA)
Tone: professional and confident but not stiff. The client should feel like they are hiring a competent partner, not a robot.
Keep the entire proposal under 800 words. Brevity signals confidence. Why it works: Most proposals are either too long or too vague. The “explicitly what is NOT included” section prevents scope creep from day one. “Brevity signals confidence” keeps Claude from padding.
- The Cold Outreach Personalizer I want to reach out to [PERSON] at [COMPANY] about [WHAT YOU OFFER].
Their role: [TITLE] Their company does: [BRIEF DESCRIPTION] Something relevant about them: [RECENT POST, ARTICLE, ACHIEVEMENT, OR COMPANY NEWS]
Write a cold email that:
- Opens with something specific to THEM (not “I hope this finds you well”)
- Gets to the point in under 3 sentences
- Clearly states what I do and why it matters to their specific situation
- Includes a low-friction CTA (not “let’s schedule a 30-minute call”)
- Total length: under 100 words
Does NOT sound like: a template, a sales pitch, or a LinkedIn connection message. Sounds like: a smart person who noticed something relevant and reached out. Why it works: The 100-word limit is the magic constraint. It forces Claude to cut everything that is not essential. The “sounds like” vs “does not sound like” instruction eliminates every bad habit of AI-generated outreach.
- The Feedback Translator I received this feedback:
[PASTE THE FEEDBACK — from a client, boss, colleague, review, etc.]
Help me:
- Strip the emotion and extract the 3 most important actionable points
- Identify what they are actually asking for vs what they said (these are often different)
- Rate severity: which points are deal-breakers and which are preferences?
- Draft a response that acknowledges the feedback, addresses each point, and sets expectations for next steps
Tone of my response: [professional / grateful / firm — pick one] Length: under 150 words Why it works: Emotional feedback is hard to process in the moment. This creates a cooling-off filter that translates feelings into actions. The “what they are actually asking for vs what they said” distinction is worth the entire prompt.
- The Meeting Killer Here is the agenda and context for an upcoming meeting:
[PASTE MEETING INVITE, AGENDA, OR DESCRIBE THE PURPOSE]
Determine:
- Can this meeting be replaced by an async document? If yes, draft that document.
- If the meeting IS necessary, what is the single decision that needs to be made?
- Who actually needs to be in the room? (Remove anyone who is there “just to be informed” — send them the notes instead)
- What is the minimum time needed? (Default to 25 minutes, justify if longer)
- Draft a 3-line pre-read that all attendees should review before the meeting so you do not waste the first 10 minutes on context
The goal is either killing this meeting or making it half as long. Why it works: The average professional spends 31 hours per month in unnecessary meetings. This prompt alone is worth an hour saved per week just by running it on your calendar once.
- The Pricing Strategy Advisor I sell [PRODUCT/SERVICE] to [TARGET AUDIENCE].
Current price: [PRICE] Current conversion rate: [IF KNOWN] Top competitors and their pricing: [LIST 2-3] My main differentiator: [WHAT MAKES ME DIFFERENT]
Analyze my pricing and give me:
- Am I underpriced, overpriced, or correctly priced? Why?
- What pricing model would maximize revenue? (one-time, subscription, tiered, usage-based)
- If I raised my price by 50%, what would likely happen? What about 100%?
- What is the specific objection buyers probably have about my price right now?
- Write one sentence I can use to justify my price when asked “why so expensive?”
Be direct. Most people underprice out of fear. If that is me, say so. Why it works: Pricing is the single highest-leverage decision in any business. A 20% price increase goes straight to profit. Most people never analyze this because it feels uncomfortable. Let Claude do the uncomfortable analysis.
- The Delegation Formatter I need to delegate this task:
[DESCRIBE THE TASK IN YOUR OWN WORDS]
Convert my description into a delegation brief with:
- Task summary (one sentence — what and why)
- Definition of done (what the finished result looks like, specifically)
- Constraints (budget, timeline, tools to use, things to avoid)
- Decision authority (what decisions they can make alone vs what needs my approval)
- Check-in points (when they should update me)
- Common mistakes to avoid (based on what typically goes wrong with this type of task)
Format it so I can paste it directly into a Slack message or email. Length: under 200 words. Why it works: Bad delegation creates more work than doing it yourself. This prompt forces clarity on the two things most people skip: “definition of done” and “decision authority.” Those two sections eliminate 80% of back-and-forth. Thinking & Strategy (22-25)
- The Reverse Brainstorm I want to [GOAL].
First, brainstorm 10 ways I could guarantee FAILURE at this goal. Be creative and specific.
Then invert each failure mode into a success strategy.
Finally, rank the 3 inverted strategies that are:
- Most counterintuitive (things I would not have thought of)
- Most actionable (I could start this week)
- Most impactful (would move the needle most)
For each of the top 3, give me a specific first step I can take tomorrow. Why it works: Direct brainstorming produces predictable ideas. Inverting failure modes produces genuinely surprising strategies. This is one of my favourite Claude techniques and it consistently generates ideas I would never have arrived at through normal thinking.
- The Pre-Mortem I am about to [DECISION / LAUNCH / PROJECT].
Imagine it is 6 months from now and this has completely failed.
Write the post-mortem:
- What went wrong? (5 specific failure points, not vague “bad execution”)
- What warning signs did I ignore?
- What did I assume that turned out to be wrong?
- Who was affected and how?
- What would I do differently if I could go back?
Then return to the present. Based on this pre-mortem:
- Which 2 failure points are most likely to actually happen?
- What can I do THIS WEEK to prevent or mitigate each one?
Be brutally honest. I would rather hear hard truths now than learn them the expensive way. Why it works: Pre-mortems are one of the most powerful strategic tools that almost nobody uses. Having Claude write the failure story from the future surfaces risks that optimism blinds you to in the present.
- The Second Brain Synthesizer Here are notes I have collected over the past [TIMEFRAME]:
[PASTE YOUR RAW NOTES, IDEAS, HIGHLIGHTS, OBSERVATIONS]
Synthesize these into:
- The 3 biggest themes or patterns across all notes
- Connections between ideas that I probably did not notice (ideas from different contexts that relate to each other)
- The single most important insight hiding in these notes
- 2 action items that emerge from the patterns
- 3 questions I should be asking based on what I have been tracking
Do not just summarize each note. Find the signal across all of them. I want emergence, not repetition. Why it works: We all capture notes and never revisit them. This prompt turns a messy collection of fragments into synthesized insight. The “connections between ideas I did not notice” instruction is where the real value lives.
- The Personal Board of Advisors I am facing this situation:
[DESCRIBE YOUR SITUATION, PROBLEM, OR DECISION]
Analyze this from 5 perspectives:
- The pragmatic operator — cares only about what works, ignores theory
- The skeptical investor — sees every risk, questions every assumption
- The creative strategist — finds unconventional angles everyone else misses
- The customer/user — does not care about my problems, only about their experience
- The long-term thinker — ignores short-term pain, focuses on where this leads in 3 years
Each advisor gives their take in 2-3 sentences.
Then synthesize their advice into one recommended action with reasoning.
If the advisors disagree on something fundamental, highlight that tension. Do not resolve it artificially. Why it works: This is the most powerful prompt on the entire list. Five perspectives produce dramatically richer analysis than one. The “do not resolve the tension artificially” instruction is critical because real decisions involve real tradeoffs that cannot be smoothed over. TL;DR 25 prompts. All tested daily. Zero gimmicks. Copy the ones relevant to your work. Paste them. Customize the brackets. Use them. The difference between someone who spends 50 hours a week working and someone who gets the same results in 40 is not talent. It is systems. These prompts are systems. This list took weeks to build and refine. If it saved you time, you know what to do. I post stuff like this regularly - AI tools, workflows, prompts, and things I actually use. No fluff, no hype, just what works. Follow me @eng_khairallah1 for more tools, workflows, and systems. No fluff. Just what works. hope this was useful for you, Khairallah
For example this before-after model run check happened in a session, related to an issue with the eu_cbm_hat model https://gitlab.com/bioeconomy/eu_cbm/eu_cbm_hat/-/work_items/144 The LLM checked out an earlier commit to see if the integration test error was the same before and after the code changes.
● I see the setup. The CI error happens because eu_cbm_hat imports eu_cbm_hat.info.harvest.combined which transitively reads country_codes.csv from EU_CBM_DATA. Locally you have that env var pointing to actual data, so import works. The fix in 5323da0 removed that import from natural_disturbances.py.
Let me reproduce by: 1. Setting EU_CBM_DATA to a non-existent path (simulating CI’s missing /root/eu_cbm/eu_cbm_data/) 2. Installing eu_cbm_hat from local checkout at commit 5cb2f5f (one before the fix) 3. Running the test → expect failure 4. Reinstalling at 5323da0 → expect success
…
● Bash(env -i HOME=/tmp/fake_ci_home PATH=/usr/bin:/bin
… ⎿ File “/tmp/eu_cbm_hat_before_144/eu_cbm_hat/post_processor/natural_disturbances.py”, line 8, infrom eu_cbm_hat.info.harvest import combined File “/tmp/eu_cbm_hat_before_144/eu_cbm_hat/info/harvest.py”, line 48, in … +27 lines (ctrl+o to expand)
● CI failure reproduced exactly. Now running the full pytest command at the pre-fix commit:
…
● Fix confirmed. All 5 tests pass with commit 5323da0. Cleaning up:
● Bash(git -C /home/paul/rp/eu_cbm/eu_cbm_hat worktree remove /tmp/eu_cbm_hat_before_144 && git -C /home/paul/rp/eu_cbm/eu_cbm_hat worktree remove /tmp/eu_cbm_hat_afte…) ⎿ /home/paul/rp/eu_cbm/eu_cbm_hat 5323da0 [main]
● Summary
CI failure reproduced and fix confirmed.
Reproduction recipe (simulates GitLab CI by hiding all of your local eu_cbm_data references):
[…]
So the CI failure is fixed by 5323da0. The pip-published eu-cbm-hat==2.1.6 on CI predates this commit — bumping the pinned version (or letting CI install latest from git) will unblock the CI job.
https://github.com/safishamsi/graphify
“Type /graphify in your AI coding assistant and it maps your entire project — code, docs, PDFs, images, videos — into a knowledge graph you can query instead of grepping through files.”
Emit a fenced markdown block (so Paul copies the raw
source), containing, for each exchange:
Paul:
❯ <question, wrapped at 88 columns, every line indented 4 spaces;
only the first line carries the ❯ prompt marker>Claude:
● <answer rendered as a blockquote: every line is 2 spaces then “>”; the first content line starts with the ● bullet>
Paul:, one
blank line, then the question as a 4-space-indented block. The first
line begins with ❯; continuation lines are just indented 4
spaces (no ❯).Claude:,
one blank line, then the answer as a blockquote — each line is 2 spaces
+ >. The first content line starts with ●.
Separate paragraphs, list groups, and sections with a blank
> or blank line.Paul:
❯ please avoid sycophancyClaude:
● Read(/home/paul/.claude/projects/-home-paul-rp-bookmarkdown/memory/MEMORY.md) ⎿ Read 5 lines
● Write(/home/paul/.claude/projects/-home-paul-rp-bookmarkdown/memory/feedback_no_sycophancy.md) ⎿ Wrote 14 lines to /home/paul/.claude/projects/-home-paul-rp-bookmarkdown/memory/feedback_no_sycophancy.md 1 — 2 name: feedback-no-sycophancy 3 description: User wants direct responses without flattery or excessive affirmation 4 metadata: 5 node_type: memory 6 type: feedback 7 originSessionId: 3e45b353-c57e-4d74-8f51-35fe80f4e96d 8 — 9 10 No sycophantic language. Don’t use phrases like “Great question!”, “That’s a smart approach”, “Bottom line:”, or add rhetorical emphasis just to make a response feel warmer. State things directly. 11 12 Why: User explicitly asked to avoid it. 13 14 How to apply: Skip affirmations, filler praise, and motivational closers. Just answer.
● Update(/home/paul/.claude/projects/-home-paul-rp-bookmarkdown/memory/MEMORY.md) ⎿ Added 3 lines 1 # Memory index 2 3 +## Feedback 4 +- No sycophancy — respond directly, no flattery or motivational closers 5 +
Paul:
❯ I meant in this conversation only and in your previous reply.Claude 10:42 AM claude-sonnet-4-6
● Understood. Let me remove that memory — it wasn’t warranted as a permanent note.
Paul
❯ how to use a cheaper model for skills I saw:
> 20% of your usage came from /run-integration-tests
> Heavy skills can be scoped down or run with a cheaper model via skill
> frontmatter.Claude
● You can set a model: field in the skill’s frontmatter. Skills live as markdown files with YAML frontmatter — adding model: claude-haiku-4-5 (or claude-sonnet-4-6) at the top makes invocations of that skill use the cheaper model.
For your run-integration-tests skill, find the file (likely ~/.claude/skills/run-integration-tests.md or under .claude/skills/ in this project) and edit the frontmatter:
---
name: run-integration-tests
description: Run pytest integration tests for
model: claude-haiku-4-5
---Valid values are claude-haiku-4-5, claude-sonnet-4-6, or claude-opus-4-7. Haiku is the cheapest and usually fine for mechanical “run this command, report results” skills like running tests.
Prompt setting for the python space:
Prompt setting the CBM space:
Talks about Human gates towards 31 min https://www.cnbc.com/video/2026/06/03/mistral-ceo-on-ai-infrastructure-sovereignty-and-europes-ai-future.html
“as employees we need to give as much context as possible to the agents who are going to be the orchestrator of processes.”
I created a bot gitlab account so that the LLM can comment on issues and triage them with a different user name than mine. That makes it more transparent for the readers.
Group service account https://docs.gitlab.com/user/profile/service_accounts/?tab=Group+service+accounts
- ” Service accounts have the following characteristics:
- They do not use a seat. - They are not billable users or internal users. - They are always marked as external users. - They cannot sign in to GitLab through the UI. [...]"
Bootstrap with Personal Access Token only needed once
“Type this — the read -s prompts you to paste the token, and because it goes in via stdin it never appears in your shell history or in the process list (ps):
read -rs OWNER_PAT # paste the glpat-… , press Enter
glab auth login --hostname gitlab.com --stdin <<<"$OWNER_PAT"
unset OWNER_PATCheck token validity
glab auth statusBootstrap sequence using my gitlab Personal Access Token to create a service account authorized for a gitlab group.
Create the service account (returns its user id + actual username)
glab api --method POST groups/--------/service_accounts -f name="triage-bot" -f username="org_triage_bot"Mint an api-scoped token for it. Use the return service account id here in place of SA_ID
glab api –method POST
groups/———/service_accounts/SA_ID/personal_access_tokens
-f name=“triage” -f “scopes[]=api” -f expires_at=“2027-07-03”
“This returns”token”:“glpat-…” once — that’s the credential the bot uses. Capture it now; you can’t retrieve it again.”
Add the service account to the project as Reporter (20)
glab api –method POST projects/org%2Forg_cbm/members
-f user_id=SA_ID -f access_level=20
Then upload the token to the server
read -rs SA_TOKEN # paste the glpat-… , Enter
ssh SERVER 'glab auth login --hostname gitlab.com --stdin' <<<"$SA_TOKEN"
unset SA_TOKENThen check that the service account works on the server
ssh SERVER 'glab api user'Paul’s 2026 setup with only one controlling agent firing sub agents for implementation and verification, with model runs in integration tests as automated gates.
Elaborate setup with triage loop, implementer agent, verifier agents and more.
Claude code on Peter Steinberger’s use of Gtihub issues :
“His replies are remarkably formulaic and commit-anchored — they read like an agent’s structured status update written by the maintainer:
- Closing a fix: “Fixed on
mainby #94148, merge commit8625b8a9…. Proof: focused doctor tests passed; live systemd run …”- Keeping something open: “Codex review: keeping this open for maintainer follow-up … Current main still has …”
- Triage/narrowing: “Deep-review update: still open on current
main, but some building blocks now exist …”
So the issue tracker functions as the steering layer for the coding agents: bots and users surface and reproduce problems, agents propose and review, and Steinberger’s comments are the authoritative signal — merge confirmation, scope decisions, “keep open” — that the agents and contributors act on. The AI work shows up in the commits too (AI-generated PRs referenced by hash), so the loop is report → agent review → maintainer decision → AI-assisted commit, all transacted inside the issue thread.”
See for example
This open issue where Peter Steinberger comments https://github.com/openclaw/openclaw/issues/92201 in a mix of user reports and AI agents commenting in the same thread + AI related commits as well of course
This is a closed issue https://github.com/openclaw/openclaw/issues/78217 with a comment by AI agent clawsweeper followed by a comment confirming the merge by Peter Steinberger
Maintainer Orchestrator https://github.com/steipete/agent-scripts/blob/main/skills/maintainer-orchestrator/SKILL.md
“Coordinate repository work through completion. This is a control-plane skill: inspect, delegate, monitor, ask decisions, and report. Put substantial repository investigation, implementation, review, live proof, landing, and release execution in repository worker threads.”
GitHub Project Triage https://github.com/steipete/agent-scripts/blob/main/skills/github-project-triage/SKILL.md
“Always use this skill when the user types triage, unless the request explicitly targets a non-GitHub domain. From inside a repo, use the current GitHub project by default. Triage means maintainer-facing item cards: URL, what each issue/PR is about, why it matters, author trust, fit, risk, proof/test state, blockers, and next action. Never return only queue numbers or opaque refs.”
https://github.com/microsoft/playwright
“Playwright is a framework for web automation and testing. It drives Chromium, Firefox, and WebKit with a single API — in your tests, in your scripts, and as a tool for AI agents.
Paul:
❯ how much does markdown prose wrapping at 88 character cost me in terms of
token when generating output?Claude
● Good question — it’s a real, measurable cost. Let me reason about the mechanism and then measure it.
The cost comes entirely from the extra newline characters. When prose is hard-wrapped, a space that would join two words (word word) becomes a line break (word). In a BPE tokenizer, word (space + word) usually merges into a single token, but is its own token and the following word loses its leading-space merge — so each wrap point costs roughly +1 token.
Let me measure it empirically with a tokenizer.
Ran 5 shell commands
● Answer
Hard-wrapping prose at 88 chars costs about 1.1–1.25 extra tokens per wrapped line, which works out to roughly 6–8% more tokens on pure-prose paragraphs (measured above with a cl100k BPE tokenizer as a proxy for Claude’s — the structural cost is essentially the same).
Why
The only thing wrapping adds is newlines. Unwrapped, the join between two words is a space that merges into the next token (” word” = 1 token). Wrapped, that join becomes + a space-less word — which tokenizes as ~2 tokens. So each wrap point costs ≈ +1 token, and an 88-char line holds ~18–20 tokens, hence ~6%.
Putting it in perspective
The 6–8% figure is a worst case — it only applies to running prose. It’s zero for everything that’s already short-lined:
- code blocks, tables, bulleted/numbered lists
- headings, short sentences, anything under 88 chars anyway
A realistic mixed answer (prose + code + lists) pays maybe 2–4% blended. In absolute terms, a typical response with 10–30 wrapped prose lines spends an extra ~11–33 output tokens — fractions of a cent even at Opus output rates.
The honest caveat on the baseline
The 6–8% is measured against one logical line per paragraph (soft-wrap), which is the only alternative that renders identically in a Markdown viewer. If instead you compared against text with the same number of line breaks but placed elsewhere, the cost is ~0 — the breaks themselves are the cost, not where they fall. So the real question isn’t “88 vs no-wrap,” it’s “do I want hard line breaks at all.” Given you read these files in a terminal and diff them in git, the readability/clean-diff payoff almost certainly outweighs a few tokens.
Want me to save this finding to memory, or measure it against Claude’s actual tokenizer via the token-counting API for a precise number?
Start claude in a project with
claudeTypical message:
“You’ve used 92% of your session limit · resets 11am (Europe/Rome) · /upgrade to keel using Claude Code”
Create agents
/agents create agentsFor example, if you named your agent “architect”, you would use @ to invoque it :
@architect help me plan the architecture for my projectSkills live in ~/.claude/commands/ and can be called with a slash such as /spell.
Content of ~/.claude/commands/accountant.md
You are an accounting assistant for a German freelance consultant using Odoo with the SKR03 chart of accounts.
When looking up account numbers, always refer to the chart of accounts at: Chart_of_Accounts.csv
…
You are a Python testing agent. Your job is to find, run, and analyze Python tests in the current project.
Workflow
- Discover the test framework: Look for
pytest.ini,pyproject.toml,setup.cfg,tox.ini, orconftest.pyto determine the test runner (pytest, unittest, nose2, etc.). Default to pytest if unclear.
- Discover tests: Find test files matching common patterns (
test_*.py,*_test.py, files intests/directories).
- Run the tests: Execute the test suite using the detected framework. Pass through any arguments the user provided: $ARGUMENTS
- If no arguments are given, run the full test suite.
- If a file path or test name is given, run only those tests.
- Use verbose output (
-v) so individual test results are visible.
- Analyze failures: For any failing tests:
- Read the relevant test code and the source code under test.
- Identify the root cause of each failure.
- Provide a clear explanation of why the test failed and suggest a fix.
- Report results: Summarize the test run with:
- Total passed / failed / skipped / errors count.
- A brief explanation for each failure.
- Suggested next steps if there are failures.
Guidelines
- Prefer
python -m pytestover barepytestto ensure the project root is onsys.path.- Respect virtual environments: check for
.venv/,venv/, orenv/directories and activate if present.- If dependencies are missing, inform the user rather than installing them automatically.
- Do not modify test files or source code unless the user explicitly asks you to fix something.
Definition of the /spell skill:
Spell-check and proofread the text provided by the user. Detect the language automatically and apply language-specific instructions.
For German text: Bitte das Deutsch in meinem Text verbessern: nur Verbesserungsvorschläge als Liste — ich werde selber schreiben.
For French text: Merci de corriger le français dans mon texte : uniquement des suggestions d’amélioration sous forme de liste — j’écrirai moi-même.
For English text: Please proofread the English in my text: provide only suggested improvements as a list — I will do the writing myself.
For any other language: Detect the language, then provide a numbered list of spelling, grammar, and style suggestions only. Do not rewrite the text.
Format: - Number each suggestion - Quote the original phrase, then show the correction - One line per issue, no explanations unless the rule is non-obvious
Authenticate with the URL sign in process.
To disconnect all connected sessions under https://claude.ai/settings/claude-code revoke the Authorization tokens. Those tokens were “Created when you sign in to Claude Code. Revoke a token to sign out from that device.” Note that this claude code token deletion is different thant the sign out of all device menu from claude settings, which doesn’t actually sign out the Claude code sessions.
Claude can navigate to websites and drive browser tabs with the chrome extension
https://claude.com/claude-for-chromeCommands
/agents create agents
/clear clear conversation history and free up context
/context display context usage in percent for system prompt, skills, tools
and messages.
/remote-control to control a claude code CLI session from the claude phone
app see also the remote control section.
/usage display usage information/accountant load mostly use account and load the chart of account used by
my consulting company on demand For general skills see the main skill section.
/fewer-permission-prompts is a skill that scans your recent transcripts for
common read-only bash calls and proposes a tailored allowlist for this
project.Prompt
Set up a dev container for this project so I can run Claude Code with
--dangerously-skip-permissions safely. Also show me the docker build and
docker run commands to start it from the terminal.Ask the model to search for a specific topic in a previous conversation, it might give you the resume command such as:
claude --resume ____________________________________When it was trying to update my vimrc which is stored in my blog
● Update(~/.vimrc) ⎿ Error: Refusing to write through symlink: /home/paul/.vimrc. Resolve the symlink and pass the real target path explicitly.
“For most setups, we recommend explicitly adding both features:”
"features": {
"ghcr.io/devcontainers/features/node:1": {},
"ghcr.io/anthropics/devcontainer-features/claude-code:1": {}
}Claude:
✻ Try the new fullscreen renderer · /tui fullscreen · Flicker-free output · Lower memory usage in long conversations · Mouse support — click to move your cursor or expand results · Selected text auto-copies to your clipboard
Paul:
❯ why is the the new fullscreen renderer · /tui called fullscreen? The old one
is also fullscreen for me? What changes in terms of rendering technology? Is it
rerendering the screen at each stroke of the keyboard?Claude:
● Good question — the name is about how it draws, not how much screen it covers. Both modes can fill your terminal window; the difference is the rendering technique underneath.
The two renderers
Old (inline / streaming) renderer
- Writes into your terminal’s normal buffer, appending lines the same way any CLI program does (echo, git log, etc.).
- Output becomes part of your scrollback history. When you scroll up in your terminal, it’s all still there, and it stays after Claude Code exits.
- The terminal itself owns scrolling and layout. Claude Code mostly just emits text and lets the terminal flow it.
New fullscreen renderer (/tui)
- Switches the terminal into its alternate screen buffer — the same mechanism vim, less, htop, and tmux use. That’s the technical meaning of “fullscreen”: it takes exclusive ownership of the viewport.
- Claude Code now manages its own layout: it positions the cursor, draws regions (input box, transcript, status line), and handles its own scrolling rather than deferring to the terminal.
- When you exit, the alternate buffer is torn down and your original shell screen returns untouched — your scrollback isn’t polluted with the session.
So “the old one is also fullscreen for me” is fair — visually both fill the window. The label refers to the alt-screen / managed-viewport approach, not the pixel coverage.
On scroll up inside tmux
The thing you specifically value — “output becomes part of scrollback history” — is a property of the inline renderer and is lost under fullscreen, because the alternate screen buffer is by design excluded from tmux pane history. The fullscreen renderer trades that away for a fixed input box and steadier in-place redraws.
Since you scroll up inside tmux often, I’d stick with the inline renderer (don’t switch via /tui, or switch back if you did). The fullscreen mode’s wins are mostly cosmetic/ergonomic for the live session; they don’t help — and the scrollback loss directly hurts — the way you work.
Later
Paul:
❯ Is there a way to search with slash in the conversation history? I used to do
this with tmux copy mode in the old terminal mode, but it's not possible now
with the new view port interface. How do I search the conversation text above?Claude:
> ● Here's the situation, and the workaround I'd use.
>
> ## Why your old trick stopped working
>
> The new viewport interface draws into the terminal's alternate screen and
> repaints in place, so the conversation isn't sitting in your terminal/tmux
> scrollback buffer anymore. That's why tmux copy-mode search (and your terminal's
> native find) can't see the text above — there's effectively nothing in the
> scrollback to search.
>
> ## What the TUI itself gives you
>
> - **Ctrl+R** — reverse-search, but only over **your own past prompts** (command
> history), not the assistant's replies or tool output.
> - **Up/Down** — step through previous prompts.
> - There is **no built-in full-text "find in conversation"** across the rendered
> transcript in the current viewport.
>
> ## The reliable workaround: grep the transcript JSONL
>
> Every session is logged as JSONL under ~/.claude/projects/<encoded-cwd>/. For
> this project that's:
>
>
> ~/.claude/projects/-projectd/
>
>
> Search the **current** session (most-recently-modified file) for, say, "Esel":
>
> bash
> grep -i "esel" "$(ls -t ~/.claude/projects/-projectd/*.jsonl | head -1)"
>
>
> For readable output (strips the JSON, shows just the text) if you have jq:
>
> bash
> jq -r '.message.content[]?|.text//empty' \
> "$(ls -t ~/.claude/projects/-projectd/*.jsonl | head -1)" \
> | grep -i "esel"
>
>
> Drop the | head -1 and use *.jsonl to search **all** sessions in this project
> at once.
>
> ## Nice bonus: you can do it without leaving Claude Code
>
> Type the command in the prompt with a leading ! and the output lands right in
> this conversation:
>
>
> ! grep -i "esel" ~/.claude/projects/-projectd/*.jsonl
>
>
> Or just ask me — "search the conversation for X" — and I'll grep it for you.
>
> One caveat: I'm confident about the JSONL-grep method (I just confirmed your
> transcript files exist), but Claude Code's in-TUI keybindings change between
> releases. If you want, I can check your installed version's keybindings to see
> whether a newer build added an in-viewport find — want me to look?Tip: Hit shift+Tab to cycle between default mode, auto-accept edit mode, and plan mode ⏸ plan mode on (shift+Tab to cycle)
❯ is the context clear if I stop and resstart claude code, or do I need to explicitely call /clear ?
● When you stop and restart Claude Code, each new session starts with a fresh context — no conversation history carries over. /clear clears the context within the current session only.
The exception is the memory system (MEMORY.md and the memory files), which persists across sessions by design.
❯ but in an earlier session I asked the following and your reply seemed to indicate the contrary? > I need to start a pyhon environment first, how to I quit and rejoin this > session later?
> You can simply quit this session and return to it later. Here's how: > - Press Ctrl+C or Ctrl+D in the terminal Or type /exit or /quit > - Just run claude code again in the same directory > Your conversation history and context will be preserved > The session is automatically saved, so when you come back and activate your > Python environment, you can continue testing the function we just > added.
● That was incorrect advice from the previous session — I was wrong. Conversation history is not preserved when you exit and restart Claude Code. Each new invocation starts with a blank slate.
The only things that persist across sessions are: - Memory files (MEMORY.md + memory files) — explicitly maintained by me - CLAUDE.md files — always loaded at startup - The files on disk (obviously)
Apologies for the earlier misinformation.
Claude Code worktrees let you run multiple Claude instances in parallel, each with an isolated copy of the codebase so they don’t step on each other’s files. How to use:
Start a new Claude session in an isolated worktree
claude –worktree
Auto-generated name
claude –worktree
This creates a git worktree at .claude/worktrees/
branched from origin/HEAD, opens a new Claude session there. Key points:
- Each worktree is a separate working directory sharing the same git history — branches, not clones.
- Gitignored files (.env, etc.) can be copied in automatically via a .worktreeinclude file.
- Cleanup is automatic: if the worktree has no changes when Claude exits, it’s removed. If it has changes, you’re prompted.
- Add .claude/worktrees/ to .gitignore.
When to use it: When you want to work on two independent tasks simultaneously — e.g., a bugfix in one session and a feature in another — without them interfering.
I have a modelling pattern where I have a code repository and a data repository.
Current practice I start Claude in the code directory and allow the data directory
{ “permissions”: { “allow”: [ “Bash(xargs -I{} sh -c ‘echo "=== {} ==="; head -3 {}’)”, “Bash(xargs -I{} sh -c ‘echo "=== {} ==="; head -5 {}’)”, “Bash(.venv/bin/python *)” ], “additionalDirectories”: [“../cbm_data”] } }
Old practice, I used to start claude code at the parent directory level
To auto allo permissions
claude --permission-mode autohttps://code.claude.com/docs/en/remote-control
“By default, Remote Control only activates when you explicitly run claude remote-control, claude –remote-control, or /remote-control”
There can be project specific CLAUDE.md within a project’s directory, generally at the root of the git repository. There is a general CLAUDE.md at
~/.claude/CLAUDE.mdContent of my general CLAUDE.md file
Markdown Style
- Wrap prose at 88 characters per line.
- Markdown table rows may exceed 88 characters.
- Do not use `---` horizontal rules as section separators; use `##` headings instead
- These rules apply to all projects unless a project-level CLAUDE.md overrides them
Docstrings
- Always use NumPy-style docstrings
- Run pdoc with `--docformat numpy` so sections render correctlyThis conversation added a python environment to a memory file for a given project.
Paul: when using python start the environment in ~/path/env
● Noted. I’ll update the memory to reflect this more clearly.
● Recalled 1 memory, wrote 1 memory (ctrl+o to expand)
● Got it — I’ll activate ~/path/env (via source ~/path/env/bin/activate or use ~/path/env/bin/python directly) whenever running Python in this project.
Paul: where is this stored in memory?
● The memory is stored in:
~/.claude/projects/-path-to-project/memory/MEMORY.md
This is a project-specific memory file that gets automatically loaded into my system prompt at the start of each conversation for this project.
Content of ~/.claude/projects/-path-to-project/memory/MEMORY.md
## Python Environment
- Always activate the virtual environment: `source ~/path/env/bin/activate` before running Python
- Or call directly: `~/path/env/bin/python` for scripts (has pandas, sqlalchemy, seaborn, etc.)
- `python` and `python3` on PATH do NOT have the required packagesA plugin that recommends skills for your project.
Call it with:
/claude-automation-recommenderInstallation:
/plugin install claude-code-setup@claude-plugins-officialj / k — line down / upCtrl-d / Ctrl-u — half-page down / upCtrl-f / Ctrl-b — full-page down / upg / G — jump to top / bottomspace — page downIntroducing: Devstral 2 and Mistral Vibe CLI. December 9, 2025 By Mistral AI https://mistral.ai/news/devstral-2-vibe-cli/
Devstral 2 on open router https://openrouter.ai/mistralai/devstral-2512
https://www.reddit.com/r/AI_Agents/comments/1negv04/is_there_really_a_lot_of_value_on_using_open/
“I think the big draw is pricing flexibility. Some tasks don’t need a $15/1M token model. You can offload to a cheaper model and save a ton at scale. OpenRouter makes that swap easy”