Most engineers I know have a folder somewhere called "notes" or "misc" or "stuff-to-remember." It holds a half-finished README, a few shell one-liners, and a config snippet that took three hours to get right. Nobody else has ever seen it.
That folder is the starting line for sharing what you learn in tech. This article is about turning it into something public without needing a big idea, a big audience, or a big time commitment.
I'm Kiran, and I focus on practical AI development, integrations, and engineering productivity, with a quality engineering mindset. That last part matters here, because sharing your work publicly is a quality problem too. You want it correct, reproducible, and useful to someone who isn't you.
The problem: learning that evaporates
You solve a problem on Tuesday. By next quarter, you've half forgotten how. By next year, a teammate hits the same wall and spends the same three hours.
Private learning has a short shelf life. Three things make it worse:
- You only remember the outcome, not the dead ends. The dead ends are what other people need.
- Explaining forces understanding. If you can't write the steps down clearly, you probably don't understand them as well as you thought.
- Teams lose knowledge silently. It lives in chat threads and in the head of whoever fixed it last.
Sharing publicly is a way to fix all three at once. It doesn't have to be a conference talk. A short, accurate post is enough.
Why starting small works
The usual blocker is the belief that you need something original. You don't. You need something specific and correct.
Compare two post ideas:
- "The future of AI in software testing"
- "How I structure a prompt so an LLM generates test cases in a consistent format"
The first has been written thousands of times and no one can verify it. The second is narrow, testable, and useful to a particular reader on a particular afternoon.
Small and specific beats broad and impressive. A reader can finish a small post, try the idea, and know whether it worked.
A simple framework: Problem, Attempt, Fix, Check
When you're unsure how to structure a post, use four parts:
- Problem: What were you trying to do, and what went wrong?
- Attempt: What did you try first? Include what failed.
- Fix: What worked, and why do you think it worked?
- Check: How can the reader verify it on their own machine?
The "Check" step is the quality engineering part. If a reader can't verify your claim, you've shared an opinion, not a lesson. Opinions are fine, but label them as opinions.
A worked example: a small, shareable lesson
Let me walk through an illustrative example. This is a hypothetical scenario, not a report of a real project, but it shows the shape of a post worth writing.
The scenario: You ask a large language model (LLM) to generate test cases for a login form, and the output format changes every time. Sometimes it's a bullet list, sometimes a table, sometimes prose. That makes it impossible to feed into any tooling.
A quick definition before the code: structured output means asking the model to return data in a fixed format, such as JSON, so another program can read it reliably. Many LLM APIs now support some form of this, but the details vary by provider, so check your provider's current documentation rather than trusting any blog post, including this one.
Attempt: a vague prompt
Write test cases for a login form.
The result is unpredictable. That's the problem, and it's worth showing in a post because it's what most people try first.
Fix: constrain the format and validate it
First, make the prompt explicit about the shape you want:
You are helping a QA engineer. Generate test cases for a login form
with fields: email, password, and a "Remember me" checkbox.
Return ONLY valid JSON, matching this shape:
{
"test_cases": [
{
"id": "TC-001",
"title": "short description",
"steps": ["step 1", "step 2"],
"expected": "expected result",
"type": "positive | negative | boundary"
}
]
}
Do not include any text outside the JSON.
Second, and this is the important part, don't trust the model to obey. Validate the output in code. Here's a small Python example using the standard library plus the jsonschema package:
import json
from jsonschema import validate, ValidationError
SCHEMA = {
"type": "object",
"required": ["test_cases"],
"properties": {
"test_cases": {
"type": "array",
"minItems": 1,
"items": {
"type": "object",
"required": ["id", "title", "steps", "expected", "type"],
"properties": {
"id": {"type": "string"},
"title": {"type": "string"},
"steps": {"type": "array", "items": {"type": "string"}},
"expected": {"type": "string"},
"type": {"enum": ["positive", "negative", "boundary"]},
},
},
}
},
}
def parse_test_cases(raw_text: str) -> list[dict]:
try:
data = json.loads(raw_text)
validate(instance=data, schema=SCHEMA)
except (json.JSONDecodeError, ValidationError) as err:
raise ValueError(f"Model output failed validation: {err}") from err
return data["test_cases"]
What this does: json.loads checks that the text is valid JSON. validate checks that the JSON has the fields and types you expect. If either fails, you get a clear error instead of a silent bad result downstream.
Add a retry, with a limit
Models sometimes return malformed output. A bounded retry handles that without looping forever:
def generate_with_retry(call_model, prompt: str, max_attempts: int = 3):
last_error = None
for attempt in range(1, max_attempts + 1):
raw = call_model(prompt)
try:
return parse_test_cases(raw)
except ValueError as err:
last_error = err
prompt = (
prompt
+ "\n\nYour previous reply was invalid: "
+ str(err)
+ "\nReturn only valid JSON matching the schema."
)
raise RuntimeError(f"Gave up after {max_attempts} attempts: {last_error}")
Here call_model is whatever function wraps your provider's API. Keeping it as a parameter means you can swap providers and, more usefully, test this logic with a fake.
Check: test your own code
A post is stronger when the reader can run something. Here's a test that needs no real model:
def test_retry_recovers_after_bad_output():
replies = iter([
"Sure! Here are some tests...", # invalid
'{"test_cases": [{"id": "TC-001", "title": "valid login",'
' "steps": ["enter creds"], "expected": "dashboard shown",'
' "type": "positive"}]}',
])
result = generate_with_retry(lambda _: next(replies), "prompt")
assert result[0]["id"] == "TC-001"
The first reply is deliberately broken. The test confirms the second attempt gets accepted. That's a verifiable claim a reader can reproduce in a minute.
What made that a good post
Look at what the example did, because the pattern transfers to almost any topic:
- It named a narrow problem. Inconsistent LLM output, not "AI in testing."
- It showed the naive attempt. Readers recognize their own first try.
- It validated instead of trusting. Model output is untrusted input, like any user input.
- It included a check. The reader can confirm it works.
- It stayed honest about limits. It pointed to provider docs instead of claiming universal behavior.
Notice what it didn't include: made-up numbers like "this improved our accuracy by 40%." Without a real measurement, that sentence is fiction. If you have real data, share it and describe how you measured it. If you don't, say what you observed and leave it there.
How to find topics when you think you have none
You don't need to brainstorm. Mine what you already did this week.
- Look at your terminal history. Commands you ran twice are candidates.
- Look at your pull request comments. Questions reviewers asked often point to non-obvious knowledge.
- Look at your bug tracker. A bug with a surprising cause makes a good post.
- Look at what you searched for. If you searched for it, others will too.
- Look at what you explained out loud. Anything you've explained to a teammate twice deserves writing down once.
A useful filter: would this have saved me an hour a month ago? If yes, write it.
Rules for sharing safely
Public writing comes with a responsibility that private notes don't. A few non-negotiables:
Never publish private information. That includes API keys, tokens, internal hostnames, customer names, proprietary code, and anything covered by your employer's confidentiality terms. Rebuild the example from scratch with fake data instead of sanitizing the real thing. Sanitizing is where leaks happen.
Check your employer's policy. Many companies have guidelines on external writing. Read them before your first post, not after.
Label hypotheticals. If an example is illustrative, say so. Readers trust you more when you're clear about what's real.
Cite what you didn't discover. If you're reporting a recent AI update, link the primary source, such as the official release notes or documentation. Don't rely on a screenshot or a secondhand summary. If you can't find a source, don't state it as fact.
Date your technical claims. AI tooling changes fast. A line like "tested with version X on this date" helps readers judge whether your advice still applies.
A lightweight publishing routine
Consistency matters more than volume. Here is a routine that fits around a full-time job:
- Keep a running list. One line per idea, added the moment it occurs to you.
- Pick one idea a month. Not five. One.
- Write the code first. Get the example working and tested before you write a word of prose.
- Draft in one sitting. Aim for 600 to 1,200 words. Edit later.
- Run it past the checklist. Is it accurate, reproducible, and free of private data?
- Publish, then leave it. Don't refresh the stats every ten minutes.
If you lead a team, you can make this a shared habit. A short internal write-up after each notable fix builds a searchable record, and the best ones can be rewritten for the public with fake data.
Handling the fear
Most people worry about being wrong in public. That's reasonable, and it's actually a good instinct to channel.
Being wrong occasionally is survivable, especially if you correct it openly. Add an update note, fix the code, and thank the person who flagged it. Readers respect that more than a flawless-looking post that quietly changed.
The other fear is that your topic is too basic. Basic topics, explained clearly, are what most readers need. Experts rarely search for fundamentals, but the many engineers who aren't experts in your particular area do.
A pre-publish checklist
Before you hit publish, run through this:
- [ ] Does the post solve one specific problem?
- [ ] Are jargon terms explained before they're used?
- [ ] Does every code sample run as written?
- [ ] Is there a way for the reader to verify the result?
- [ ] Are hypothetical examples labeled as hypothetical?
- [ ] Are all numbers and claims either measured by you or linked to a source?
- [ ] Is every secret, customer detail, and internal name removed?
- [ ] Does it mention the versions and date it applies to?
If you can check every box, publish it.
Conclusion
Sharing what you learn doesn't require expertise at the level of a famous speaker. It requires noticing what you figured out, writing it down accurately, and giving the reader a way to check your work.
Start with the folder of notes. Pick the one item that cost you the most time. Write it up as Problem, Attempt, Fix, Check. Build the example from scratch with fake data, test it, and publish it.
That single post will help a future teammate, a stranger with the same bug, and you, six months from now, when you've forgotten how you solved it.
So here's my question for you: what's the one thing you figured out in the last month that you wish had been easier to find? That's probably your first post.
Top comments (0)