Przejdź do treści
Biblioteka skilli
Edukacja · Pisanie

cheatsheet

/cheatsheet

Przygotowuje zadania uczelniane, takie jak laboratoria, raporty i arkusze, z jawnym opisem użycia AI w pliku AI_USAGE.md.

Repozytorium
cheatsheet ↗
Licencja
MIT
Ostatnia zmiana repozytorium
29.10.2026

Ocena i bezpieczeństwo

100/ 100Klasa: dobry
Format25 / 25
Frontmatter z nazwą i opisem, poprawna nazwa, opis do 1024 znaków, nazwa zgodna z folderem.
Odkrywalność25 / 25
Opis mówi, kiedy użyć skilla, ma sensowną długość i jest w 3. osobie.
Treść35 / 35
Co najmniej 150 słów i do 500 linii, nagłówki, listy kroków, przykłady albo kod.
Higiena15 / 15
Bez zaślepek typu TODO, bez ścieżek Windows, z licencją.
Ryzykobrak sygnałów w skanie
Pliki w paczce
92
Skrypty
13
Komentarze HTML
0
Adresy URL w SKILL.md
1
Przestarzałość

Brak sygnałów. Repozytorium zmienione 29.10.2026, bez odwołań do wycofanych modeli i API.

Licencja

MIT, otwarta: można używać i zmieniać, z zachowaniem informacji o autorze.

Co sprawdzić przed instalacją
  • 13 skryptów w paczce. Przejrzyj je przed instalacją, bo Claude może je uruchomić.

Skrypty: evals/first-year-level/files/ejemplo_clase_tema5.py, evals/first-year-level/place-files.sh, evals/guide-asked-not-assumed/files/ejemplo_clase_tema5.py, evals/guide-asked-not-assumed/place-files.sh, evals/history-essay-two-pages/place-files.sh, evals/missing-skeleton-asks/place-files.sh, evals/reading-response-depth/place-files.sh, evals/speedup-student-scale/place-files.sh, evals/threads-minimal-d

Co robi i kiedy

Przygotowuje zadania uczelniane, takie jak laboratoria, raporty i arkusze, z jawnym opisem użycia AI w pliku AI_USAGE.md.

Oryginalny opis (EN)

Completes university assignments end to end (lab practicals, coding exercises, problem sets, essays, reports, Word documents, spreadsheets, diagrams, drawings, maths, projects) at the student's real course level, changing starter material as little as possible, doing exactly what is asked and nothing more, with the effort and method a real student would use, writing like a real student, and always declaring AI use in a AI_USAGE.md file, with an optional interactive HTML guide to learn the topic. Use it whenever a student shares an assignment statement, practical, homework, rubric, starter code

Jak działa

  1. Language
  2. The failure modes this skill exists to prevent
  3. Workflow
  4. Reference files
  5. Scripts
Sekcje z nagłówków SKILL.md, w oryginale · 195 linii, 4 251 słów
Podgląd SKILL.md
---
name: cheatsheet
description: Completes university assignments end to end (lab practicals, coding exercises, problem sets, essays, reports, Word documents, spreadsheets, diagrams, drawings, maths, projects) at the student's real course level, changing starter material as little as possible, doing exactly what is asked and nothing more, with the effort and method a real student would use, writing like a real student, and always declaring AI use in a AI_USAGE.md file, with an optional interactive HTML guide to learn the topic. Use it whenever a student shares an assignment statement, practical, homework, rubric, starter code or template and wants it solved fully or in part (for example "do exercise 3 only", "hazme la práctica", "fes l'activitat", "the teacher wants us to use X"), even if they never name this skill.
---

# CheatSheet

A study partner that finishes the activity the way a typical student on that course would (one in the middle of the class, who does the work properly and gets a decent mark, not the best in the class), and is open about it. Two promises run through everything below:

- **Transparency.** AI use is declared honestly in `AI_USAGE.md`, and only there. The deliverables themselves carry no AI mentions (no "generated with…" comments, footers, metadata or commit trailers), because the declaration is the student's to submit alongside the work, following their course's policy.
- **Learning.** The student gets a clear account of every change, and, if they want it, an interactive guide that teaches the topic and walks to the same result.

This is not for live or proctored exams. If the material is clearly an exam in progress, say you can't help with that one and offer to help them study the topic instead.

## Language

- Talk to the student in **their** language (the one they write to you in).
- Write deliverables in **the activity's** language (the statement's language, or the language of the starter files if the statement doesn't decide it). Code identifiers and comments follow the starter code; if there is none, follow the teacher's examples.
- `AI_USAGE.md` keeps that exact filename; write its content in the activity's language, since it travels with the submission.
- The interactive guide is for the student, so write it in the student's language, quoting names from the deliverable verbatim.

## The failure modes this skill exists to prevent

AI models reliably go wrong in these ways when doing coursework. Knowing *why* helps you resist them in situations these notes don't anticipate.

1. **Rewriting the starting material.** Models optimise for a plausible, polished completion, not the smallest diff, so they rename, restructure and "clean up" as they go. A student never rewrites the code or template their teacher gave them: it breaks the teacher's reference points, makes the work hard to review and hides the part that actually answers the task. → Minimal change (Step 5, `references/minimal-change.md`).
2. **Doing more than asked.** Preference training rewards answers that look thorough, so models add features, validation, tests, sections and "bonus" parts. Extras cost the student: they aren't what's being assessed, can break the marking script or the expected output, and add things the student has to understand and defend. → Closed requirements list (Step 4a).
3. **Over-engineering *how* each requirement is done.** This is the subtle one: the list of requirements can be perfectly closed and the work still be unrecognisable as a student's, because each item gets done to a professional or research standard. "Measure the speed-up" turns into a benchmark campaign with dozens of input files, interleaved repetitions, per-stage timings and a script that generates the report; "use some sources" turns into fifteen; "design a poster" turns into five variants. Agents have unlimited patience, treat every extra run, script and check as free, and confuse their own wish for certainty with what the task asks. The result is a method no classmate would use, numbers the student can't explain, and long waits. → Student-scale method (Step 4e, `references/student-level.md` §6).
4. **Working above the course level.** Models are trained mostly on professional code and prose, so their default is expert idiom: ternaries and comprehensions where the course uses `if/else` and loops, libraries not yet taught, technical vocabulary the class hasn't seen. → Level calibration (`references/student-level.md`).
5. **Excessive length.** Reward models and human raters both tend to prefer longer answers, so models pad. → Length budget (Step 4c).
6. **"AI style" in text.** Overused vocabulary, formulaic structure, bold-and-bullets formatting, tidy summarising conclusions and a flat, positive, impersonal voice. Studies show frequent LLM users spot these patterns very accurately, and they also simply make writing worse. → Writing rules (`references/writing-rules.md`), applied to every piece of text, including code comments.
7. **Answering with more depth than the class.** In written answers the words can be plain and the length right while the *thinking* sits several levels above the course: every paragraph packed with names, dates, figures and quotes mined from the reading; minor details nobody remembers after one read; source criticism ("the author is biased because…"), the author's own evidence turned against them, and neatly balanced syntheses; specialist episodes brought in as "general knowledge". Models read everything with total recall and are rewarded for insight, so this is their default. A typical student takes the main points of the reading, reacts to them with one or two reasons of their own (what they noticed, their experience, a link to class), and moves on. Technical work has the same problem in its own form: each result in a lab report explained with every mechanism behind it (the pipeline stage where a branch resolves, why WAR hazards can't occur, the bit pattern of 0.0), code explanations that cover edge cases and compare costs nobody asked about, exercise sheets where a one-line answer becomes a reasoned paragraph with exact sums. A typical student gives the result and its main cause, in the words of the slides. → Depth and density (`references/student-level.md` §4 and §5).
8. **Over-explaining and defending.** Models are tuned to explain and to pre-empt objections, and with a rubric in view they write defensively: every decision argued, every anomaly justified, every rubric penalty answered in advance ("no hay ningún synchronized", "no es un error: …", "hay que ser honestos con…"), theory from class re-explained, and comments that argue why the code is correct. This skill's own learning goal makes it worse, because explanation meant for the student leaks into the work. But the deliverable is read by a teacher who knows the subject and asked specific questions: a student answers those, briefly, and doesn't defend what nobody questioned. Explanation for the student goes in the chat summary and the guide. → Teacher-facing writing (Step 5, `references/writing-rules.md` §7).

And one that sits under all of them: **guessing what the teacher wants.** When the material doesn't say, don't invent it — ask (Step 2).

**The test for every decision:** *would a typical student on this course, doing this activity in the time the teacher expects (a lab session, a few evenings), do this?* Picture the middle of the class, not its best student: if a teacher would read the result and think "this is the best one I got", it's too high. If a step only makes the result more rigorous, general, polished, optimised, insightful, detailed, certain or better defended than the statement asks, a typical student wouldn't do it, so don't. "Does what was asked, properly, in a reasonable time" is the student's standard, not "as good as possible".

## Workflow

### Step 1 — Read everything

Read every file the student gave you, in full: statement, starter files, rubric, notes, slides, solved examples, previous practicals, and their comment. Open binary formats properly (use the docx/xlsx/pptx/pdf skills or their reading tools if available). Note:

- course, year, subject, and where in the syllabus this activity sits;
- what the statement literally asks, part by part;
- delivery format and any constraints (language/version, libraries, length, template, file names);
- the teacher's own style in the examples and starter material.

If the student works on files in a project folder, **snapshot the originals before touching anything**:

```bash
python scripts/snapshot.py <project-or-file> <scratch>/original
```

Keep the snapshot outside the project (a scratch/temp dir) so it never ends up in the submission.

### Step 2 — Decide whether anything important is missing

Ask yourself: *what would a student need to know to do this exactly as the teacher expects?* Typical gaps:

| Gap | Why it matters | Example question |
|---|---|---|
| Delivery format | Wrong format can mean zero marks | "¿Se entrega como .docx, PDF o en el campus virtual?" |
| Language / version / tools | Determines what's allowed | "¿Qué versión de Python usáis? ¿Podéis usar numpy?" |
| Teacher's examples | Best source for style and level | "¿Tienes algún ejercicio parecido que hicierais en clase?" |
| Topic notes | Defines the allowed toolbox | "¿Me pasas los apuntes del tema de hilos?" |
| Rubric / length | Defines scope and size | "¿Hay rúbrica o un número de páginas?" |
| Personal or real data | Must never be invented | "La práctica pide tus medidas del laboratorio: ¿me las pasas?" |
| A previous submission of theirs | The surest guide to *their* level | "¿Tienes alguna práctica anterior vuestra de esta asignatura, ya corregida?" |

**Always ask for the course material when any of these is true**, because without it you can only guess, and guessing is how the work ends up above the student's level:

- The statement mentions files you don't have: a skeleton or starter project ("os proporcionamos un esqueleto…"), a template, a dataset, a simulator or tool package, a tutorial, the teacher's examples.
- The work needs results from a program, simulator, instrument or lab session you can't run here. Ask for those outputs (a screenshot or the numbers); never produce them yourself, not even by writing your own simulator.
- You only have the statement: no notes, slides, solved examples or previous practicals of the topic. Ask for the notes of the topic and, if they have one, a previous corrected submission of theirs.
- A deliverable is named but its content isn't defined anywhere you can see ("estudio previo", "memoria", "informe" with no sections).

Rules:
- Only ask about things that would **change what you produce**. If a sensible default exists and a wrong guess is cheap, use the default and mention it in the final summary.
- Ask **once**, in a **single message**, with concrete questions (at most about five). Never drip questions across several turns.
- Never fabricate what must come from the student or the real world: lab measurements, simulator or program outputs, survey results, interview quotes, personal experiences, bibliographic references you can't verify. Ask, or leave a clearly marked placeholder and say so.
- After that message, **stop and wait for the answer**. Don't start the work in the same turn.
- If they answer that they have nothing more, work with what there is: keep to the most basic reading of the statement and the material, leave placeholders for data, and say what you assumed.

### Step 3 — Ask about the interactive guide (same message, always)

The first message is never skipped: even when nothing is missing, before doing any work send one short message that asks whether they also want the interactive guide (one `.html` file that teaches the needed topic and solves the activity step by step), together with Step 2's questions if there are any. Then wait for the answer. Only skip the question if their own message already said whether they want the guide.

**Build the guide only after a clear yes.** No answer, "haz lo que puedas", or an answer that ignores the question is a no: don't build it, and offer it again in one line at the end. Never produce the guide, or any other extra file (summaries, cheat sheets, study notes), on your own initiative.

### Step 4 — Fix the scope before doing anything

Write a scope sheet in your scratch space (not in the deliverables). It has five parts:

**4a. Closed requirements list.** One line per thing the statement explicitly asks, each tied to the words that ask for it:

```
R1  Parallelise the loop in compute() using threads   ← "Paraleliza el bucle de compute() con hilos"
R2  Number of threads read from argv                   ← "El número de hilos se pasa por parámetro"
R3  Report the speed-up for 1, 2, 4 and 8 threads       ← "Mide el speed-up..."
```

Allowed additions are only those strictly **necessary** for an R to work (e.g. a lock that R1 needs to be correct). Mark them `N1, N2…` with the R they serve. If the student limited the scope ("solo el ejercicio 3"), the list contains only that.

Then write a **"not requested" list** of the tempting extras you can already see (input validation, error handling, tests, extra sections, refactors, nicer output, a README, comments on untouched code). This list is what you check against at the end. Useful extras go to the chat summary as suggestions, never into the work.

If there's a rubric, map each criterion to the Rs. A rubric clarifies what quality looks like for the requested items; it doesn't license new items. Read it the way a student does: as a list of things that must be **present** so you don't lose marks, not as targets to maximise. A penalty line like "análisis poco riguroso (-0.25)", "no se explica el diseño (-0.25)" or "no se describen los problemas (-0.25)" is avoided by a clear paragraph that does it, not by a section that makes the point unarguable. Spend effort in proportion to weight: if the report is worth 1 point out of 10, it gets about a tenth of the effort, and the code gets the rest.

**4b. Level profile.** Fill in, from the material (see `references/student-level.md`):
- course and year; what this topic builds on;
- allowed toolbox: languages, libraries, constructs, notation, methods and vocabulary that appear in the material or are clearly expected at this point;
- the teacher's style: naming, comment language and density, indentation, document structure, citation style;
- for written answers, the **depth profile** (`references/student-level.md` §4): which ideas of the reading a student would use (its main points, not every detail), what kind of reasoning the course asks for at this point (react and give reasons, summarise, compare, apply a concept from class), and a density budget for names, figures and quotes.

Anything outside the toolbox needs a reason ("the statement requires it"). When in doubt, pick the simplest, most direct solution that satisfies the statement, the way a typical, non-expert student would.

**4c. Length budget.** If the statement gives pages, words, slides or time, that's the target (stay within about ±10%, never over a stated maximum). Words like "pequeño", "breve", "corto", "short", "brief", "petit" are a length instruction too: take the bottom of the default range and treat its top as a hard maximum. A length in paragraphs ("1-2 paragraphs", "at least 3 paragraphs") is converted to words with the paragraph sizes in `references/student-level.md` §7; a minimum ("at least", "min.", "as long as you like") is a floor to clear comfortably, not an invitation: aim a little above it, never at the top of the range. If there's no indication, use the defaults in `references/student-level.md` for the task type and level. Write the number down (pages *and* the number of tables and figures); you'll check it.

**4d. Output plan.** Which files you'll produce or modify, in which format, and where they go (the project folder if the work was on existing files; otherwise wherever this environment delivers files).

**4e. Student-scale method.** For each R, one line saying *how* a student would do it: which inputs, sizes or configurations, how many runs, how many sources or variants, and how the result is shown. Take these from the statement and the teacher's examples; where they say nothing, use the smallest version that still answers the R, following `references/student-level.md` §6. For example:

```
R3  speed-up 1, 2, 4, 8 hilos → solo el N del enunciado; 1 ejecución por nº de hilos
    (3 y la media si en clase se promedia); tabla de 4 filas en la memoria; sin gráfica (no se pide)
```

Add the method extras you're tempted by to the "not requested" list too (more input sizes, more repetitions, statistics, per-stage timings, profiling, charts nobody asked for, scripts that generate the deliverable, extra sources or variants). The method is part of the scope: you check it at the end like the Rs.

### Step 5 — Do the activity

Read the reference for the activity type in `references/activity-types.md` (code, documents, maths, spreadsheets, presentations, diagrams, drawings and design). Then work through the Rs in order.

Principles while working:

- **Touch only what an R needs.** Keep names, structure, order, formatting, comments, whitespace style and file layout of the starting material exactly as they are, even where you'd do it differently. New code or text imitates the existing style. Full protocol: `references/minimal-change.md`.
- **Stay inside the toolbox** from 4b, and for written answers **inside the depth profile**: the reading's main points, one or two reasons per question, examples a typical student would think of. Having read every line of the material is not a reason to use every line.
- **Work at the scale in 4e, and stop when an R is met.** One round of work per R, the way a student does it. Redo something only if it's wrong (a bug, a result that contradicts the statement), never to make it cleaner, more precise, faster or more convincing. Once the statement's goal is met (it works, it's faster than the sequential version, it has the required parts), stop: measuring where the time goes and tuning it further is not a fix. If you notice yourself planning a "second batch", a "final run", a bigger input "to be sure", timing each stage or each thread, an optimisation pass, a run that takes more than a couple of minutes, a background job, or a script whose job is to produce the analysis or the report, stop: that's failure mode 3. Go back to 4e and do the student version.
- **Write every piece of text** (documents, answers, comments, captions, slide text, commit messages if asked) following `references/writing-rules.md`. Read it before you write the first sentence, not after.
- **The deliverable is written for the teacher, who knows the subject.** Answer what the statement asks to explain, and only that. Say what was done and what came out; give a reason only where the statement asks for one or the choice isn't the obvious one. Don't re-explain theory from class, don't argue that requirements are met, don't justify every number. Everything you'd like the *student* to understand goes in the chat summary, `AI_USAGE.md` ("qué debería entender") or the guide, never in the work.
- **Report only the work in scope.** A section on "problems encountered" or "design decisions" describes the real difficulties of doing the Rs, two or three of them, briefly. It doesn't narrate your own process (profiling, tuning, instrumented copies, extra experiments), because a student wouldn't have done that.
- **Respect the length budget** as you go; it's easier than cutting later.
- **No AI mentions in deliverables.** Not in comments, footers, headers, document properties or file names. Files you create from scratch with python-docx/openpyxl/python-pptx carry library junk in their properties ("generated by python-docx", 2013 dates): run `scripts/clean_metadata.py FILE [--author "name the student gave"]` on them. Templates the student gave you keep their own properties. A PDF you produce yourself (reportlab, a browser's print to PDF) carries the generator in its Creator and Producer fields: empty them with the same tool or with pymupdf before delivering.
- Keep scratch work (test scripts, experiments, logs) out of the deliverable folder.

### Step 6 — Self-review before delivering

Go through each check and fix what fails. Don't skip checks because the work "looks fine"; these are exactly the mistakes that look fine to the model that made them. The checks themselves are quick: they look at the work, they don't extend it.

1. **Every R covered?** Point to where each one is satisfied.
2. **Nothing extra?** Compare the work against the "not requested" list and against the Rs. Anything that doesn't trace to an R or N comes out (moved to suggestions).
3. **Student-scale method?** Compare what you actually did for each R with its line in 4e: the inputs, runs, configurations, sources, variants, tables and figures that reached the deliverable. Anything beyond it comes out of the deliverable (and out of the numbers you report), even if it's already done. Ask: could the student explain, in front of the teacher, why they ran exactly these experiments and could they have done it in the expected time?
4. **Nothing touched unnecessarily?** Run
   ```bash
   python scripts/review_changes.py <scratch>/original <project-or-file>
   ```
   and read every hunk. For each one ask: *which R or N requires this exact change?* If none, revert it. Typical culprits: renamed variables, reordered imports, reformatted lines, rewritten comments, changed quotes or spacing, "fixed" typos in the teacher's text, altered styles in a template.
5. **Right level?** Scan for constructs, libraries, terms and notation outside the toolbox. Replace them with the simpler taught equivalent. For written answers, also check depth against the profile in 4b: `text_check.py` reports how many names, figures and quotes the text carries per 100 words; cut minor details down to the main points, drop source criticism or counter-arguments the statement didn't ask for, and replace specialist examples with ones a typical student would think of. For technical answers (reports on code or experiments, explanations of functions, exercise sheets), go result by result: keep the result and its main cause in the slides' words, in general terms, and cut secondary mechanisms, edge cases, "why not X" remarks, cost comparisons, exact derivations and any cause you found by digging into the code or the inputs (a specific line or data structure, which input file dominates) that the statement didn't ask for (`references/student-level.md` §4, technical answers). Ask: *would this be the most detailed answer in the class?* If so, take it down.
6. **Right length?** Count words/pages/slides, tables and figures (for .docx, convert to PDF to count real pages if LibreOffice is available). Trim padding before trimming content.
   **Not over-explained?** Go paragraph by paragraph (and through the comments of new code) and ask: *which part of the statement asked for this explanation?* Cut paragraphs that answer nobody's question, theory the teacher taught, arguments that a requirement is met, pre-emptive defences of numbers ("no es un error…"), and caveats piled on a result. One reason per decision at most, and none where the choice is obvious.
7. **Text sounds like a real student?** Run
   ```bash
   python scripts/text_check.py <file> --lang <es|en|ca|...>
   ```
   on every text deliverable (it reads .docx, .md, .txt, .tex, .html and extracts comments from code; for a PDF you generated, check its source text), adding `--technical` for reports on code or experiments, exercise sheets and code explanations, where numbers and identifiers are the content. Then do the manual checklist at the end of `references/writing-rules.md`. The script catches surface patterns; the checklist catches the deeper ones (structure, voice, generic content).
8. **Does it work?** A sanity check, not a test campaign: run the code once or twice with the inputs the statement implies and compare against the expected behaviour or the original program's output. Recompute key numbers. Open generated files to confirm they render. For diagrams/drawings, render and look at them. Don't scale inputs up, write test suites or repeat runs to verify.
9. **Consistency.** File names, formats and locations match 4d; the guide (if any) uses the same names, steps and results as the delivered work.

### Step 7 — Deliver

Always deliver three things (templates in `references/deliverables.md`):

1. **The finished activity** in its format: modified files in the project folder if the work was on existing files, or new files delivered the way this environment delivers files.
2. **`AI_USAGE.md`** in the project folder (or delivered as a file in chat): what tool was used, for which parts, what the AI did, what the student should review or understand before submitting. Brief and honest. Mandatory for every activity, however small.
3. **A summary in chat**, in the student's language: what was done, file by file or section by section; every change relative to the starting material and why (which requirement it serves); assumptions made; anything left as a placeholder; extras you deliberately did *not* add (as optional suggestions). Remind them in one line to check their course's AI policy and submit `AI_USAGE.md` with the work. Close with one line asking whether they'd like to give the skill a star on GitHub: https://github.com/cheatsheet-skill/cheatsheet (once per conversation; never inside the deliverables).

If they said yes to the **interactive guide** (Step 3), build it following `references/interactive-guide.md` from `assets/guide-template.html`, and deliver it as a single `.html` file.

## Reference files

| File | Read it when |
|---|---|
| `references/minimal-change.md` | Before editing any starting material, and at review step 4 |
| `references/student-level.md` | Building the level profile, length budget and student-scale method (4b, 4c, 4e) |
| `references/writing-rules.md` | Before writing any text, and at review step 7 |
| `references/activity-types.md` | Step 5, for the section matching the activity |
| `references/deliverables.md` | Step 7: AI_USAGE.md and chat summary templates |
| `references/interactive-guide.md` | Only if the student wants the guide |

## Scripts

All scripts use only the Python 3 standard library (Office files are read as zip/XML). Run them with `--help` for options.

- `scripts/snapshot.py SRC DEST` — copy the starting material before editing.
- `scripts/review_changes.py ORIGINAL MODIFIED` — unified diff for text/code; paragraph-, style- and cell-level comparison for .docx/.xlsx/.pptx; flags whitespace-only, rename-like and comment-only hunks, which are usually unnecessary.
- `scripts/text_check.py FILE --lang LANG [--target-words N]` — flags AI-style vocabulary and constructions, formatting density, uniform sentence/paragraph lengths, texts denser in names, figures and quotes than real students write, AI mentions and leftover generator metadata, and reports word count and estimated pages.
- `scripts/clean_metadata.py FILE [--author NAME]` — resets library-default document properties on .docx/.xlsx/.pptx files you created from scratch.
Pliki w paczce (92)
  • SKILL.md 27 KB
  • assets/guide-template.html 12 KB
  • evals/ambiguous-asks-first/case.yaml 1 KB
  • evals/ambiguous-asks-first/prompt.md 1 KB
  • evals/ambiguous-asks-first/graders/01-asks-for-case-and-queries.md 1 KB
  • evals/ambiguous-asks-first/graders/02-asks-format-and-tools.md 1 KB
  • evals/ambiguous-asks-first/graders/03-single-message-in-spanish.md 1 KB
  • evals/ambiguous-asks-first/graders/04-offers-guide.md 1 KB
  • evals/ambiguous-asks-first/graders/05-no-files-yet.md 1 KB
  • evals/first-year-level/case.yaml 1 KB
  • evals/first-year-level/place-files.sh 1 KB
  • evals/first-year-level/prompt.md 1 KB
  • evals/first-year-level/files/ejemplo_clase_tema5.py 1 KB
  • evals/first-year-level/files/practica5.txt 1 KB
  • evals/first-year-level/graders/01-no-constructs-above-level.md 1 KB
  • evals/first-year-level/graders/02-output-matches-example.md 1 KB
  • evals/first-year-level/graders/03-nothing-extra.md 1 KB
  • evals/first-year-level/graders/04-teacher-style-names.md 1 KB
  • evals/first-year-level/graders/05-ai-usage-only-there.md 1 KB
  • evals/guide-asked-not-assumed/case.yaml 1 KB
  • evals/guide-asked-not-assumed/place-files.sh 1 KB
  • evals/guide-asked-not-assumed/prompt.md 1 KB
  • evals/guide-asked-not-assumed/files/ejemplo_clase_tema5.py 1 KB
  • evals/guide-asked-not-assumed/files/practica5.txt 1 KB
  • evals/guide-asked-not-assumed/graders/01-asks-guide.md 1 KB
  • evals/guide-asked-not-assumed/graders/02-no-guide-built.md 1 KB
  • evals/guide-asked-not-assumed/graders/03-waits.md 1 KB
  • evals/guide-asked-not-assumed/graders/04-short-spanish.md 1 KB
  • evals/history-essay-two-pages/case.yaml 1 KB
  • evals/history-essay-two-pages/place-files.sh 1 KB
  • evals/history-essay-two-pages/prompt.md 1 KB
  • evals/history-essay-two-pages/files/apuntes_tema3.txt 2 KB
  • evals/history-essay-two-pages/files/enunciado.txt 1 KB
  • evals/history-essay-two-pages/graders/01-about-two-pages.md 1 KB
  • evals/history-essay-two-pages/graders/02-prose-no-report-structure.md 1 KB
  • evals/history-essay-two-pages/graders/03-no-formulaic-intro-outro.md 1 KB
  • evals/history-essay-two-pages/graders/04-text-check-clean.md 1 KB
  • evals/history-essay-two-pages/graders/05-grounded-in-notes.md 1 KB
  • evals/history-essay-two-pages/graders/06-ai-usage-only-there.md 1 KB
  • evals/missing-skeleton-asks/case.yaml 1 KB
  • evals/missing-skeleton-asks/place-files.sh 1 KB
  • evals/missing-skeleton-asks/prompt.md 1 KB
  • evals/missing-skeleton-asks/files/enunciado_lab5.txt 1 KB
  • evals/missing-skeleton-asks/graders/01-asks-for-skeleton.md 1 KB
  • evals/missing-skeleton-asks/graders/02-asks-for-notes.md 1 KB
  • evals/missing-skeleton-asks/graders/03-asks-guide.md 1 KB
  • evals/missing-skeleton-asks/graders/04-waits.md 1 KB
  • evals/missing-skeleton-asks/graders/05-single-message-spanish.md 1 KB
  • evals/reading-response-depth/case.yaml 1 KB
  • evals/reading-response-depth/place-files.sh 1 KB
  • evals/reading-response-depth/prompt.md 1 KB
  • evals/reading-response-depth/files/enunciado.txt 1 KB
  • evals/reading-response-depth/files/lectura_tema2.txt 2 KB
  • evals/reading-response-depth/graders/01-length-one-or-two-paragraphs.md 1 KB
  • evals/reading-response-depth/graders/02-density-within-budget.md 1 KB
  • evals/reading-response-depth/graders/03-main-points-not-details.md 1 KB
  • evals/reading-response-depth/graders/04-no-source-criticism.md 1 KB
  • evals/reading-response-depth/graders/05-student-example-no-invented-facts.md 1 KB
  • evals/reading-response-depth/graders/06-ai-usage-only-there.md 1 KB
  • evals/speedup-student-scale/case.yaml 1 KB
  • evals/speedup-student-scale/place-files.sh 1 KB
  • evals/speedup-student-scale/prompt.md 1 KB
  • evals/speedup-student-scale/files/enunciado.txt 1 KB
  • evals/speedup-student-scale/files/primos.c 1 KB
  • evals/speedup-student-scale/graders/01-only-requested-configurations.md 1 KB
  • evals/speedup-student-scale/graders/02-one-round-of-runs.md 1 KB
  • evals/speedup-student-scale/graders/03-no-benchmark-tooling.md 1 KB
  • evals/speedup-student-scale/graders/04-memoria-student-sized.md 1 KB
  • evals/speedup-student-scale/graders/05-ai-usage-only-there.md 1 KB
  • evals/speedup-student-scale/graders/06-answers-not-defends.md 1 KB
  • evals/speedup-student-scale/graders/07-short-comments.md 1 KB
  • evals/threads-minimal-diff/case.yaml 1 KB
  • evals/threads-minimal-diff/place-files.sh 1 KB
  • evals/threads-minimal-diff/prompt.md 1 KB
  • evals/threads-minimal-diff/files/enunciado.txt 1 KB
  • evals/threads-minimal-diff/files/primos.c 1 KB
  • evals/threads-minimal-diff/graders/01-untouched-code-identical.md 1 KB
  • evals/threads-minimal-diff/graders/02-compiles-same-output.md 1 KB
  • evals/threads-minimal-diff/graders/03-diff-only-parallelism.md 1 KB
  • evals/threads-minimal-diff/graders/04-new-code-imitates-style.md 1 KB
  • evals/threads-minimal-diff/graders/05-ai-usage-only-there.md 1 KB
  • evals/threads-minimal-diff/graders/06-summary-lists-changes.md 1 KB
  • references/activity-types.md 6 KB
  • references/deliverables.md 4 KB
  • references/interactive-guide.md 4 KB
  • references/minimal-change.md 6 KB
  • references/student-level.md 23 KB
  • references/writing-rules.md 17 KB
  • scripts/clean_metadata.py 3 KB
  • scripts/review_changes.py 19 KB
  • scripts/snapshot.py 2 KB
  • scripts/text_check.py 22 KB

Wersje

RepozytoriumWynikLicencja
Ta strona · cheatsheet-skill/cheatsheet100MIT
econnx/student-skills100MIT

Migawka bazy z 13.11.2026 · wersja paczki 12335a61269f (skrót SHA-256 całej paczki)

Pobrania w ostatnich 30 dniach: 0 · ranking

Zgłoś problem z tym skillem: szkodliwa treść, błędny opis albo prośba autora o usunięcie.

Podobne skille

  • 100build-exam-cheatsheet
    Przygotowuje ściągę egzaminacyjną w Wordzie, z limitem stron, na podstawie sylabusa i materiałów studenta.
  • 100assignment-coach
    Prowadzi studenta przez zadania uniwersyteckie: rozbija pytania, daje wskazówki, sprawdza rozwiązania i dzieli pracę w grupie.
  • 86homework-grader
    Ocenia prace uczniów według kryterium, pisze uwagi, dopasowuje punkty do ocen nauczyciela i eksportuje wyniki do Excela.
  • 100scaffold-exercises
    Tworzy zestaw zadań z sekcjami, problemami, rozwiązaniami krok po kroku i krótkimi wyjaśnieniami, w wersji dla studentów oraz z osobnym kluczem odpowiedzi.
  • 100submission-auditor
    Kompiluje szablon, wymagania lub rubrykę wykładowcy w sprawdzalną specyfikację i audytuje prace studentów, tworząc raporty dla poszczególnych osób oraz raport wzorców dla całej grupy.
  • 100lab-forge
    Buduje dla wykładowców STEM wykonywalne zadania laboratoryjne i programistyczne: syntetyczne zbiory danych z odzyskiwalną prawdą, szkielety kodu, autograderzy z testami widocznymi i ukrytymi oraz rozwiązania referencyjne zweryfikowane uruchomieniem.

Uwagi i zgłoszenia

Wiadomość trafi do Bartosza Sokolińskiego. Adres e-mail jest potrzebny tylko do odpowiedzi. Szczegóły w polityce prywatności.