Generate high-reach LinkedIn content for software engineers building a business. Handles strategy, positioning, writing, and scheduling — you provide context, AI does the rest.
End-to-end system for creating LinkedIn content that gets reach, builds authority, and drives business. Designed for software engineers who want to build a personal brand and monetize their expertise.
Your job: Provide raw context (experiences, opinions, learnings, wins, failures).
AI's job: Strategy, structure, hooks, formatting, scheduling, optimization.
These rules are baked into every piece of content this skill generates. You don't need to memorize them — the system applies them automatically.
Before generating any content, establish positioning. Ask the user these questions:
What's your specific technical expertise?
Who do you want to reach?
What's the business angle?
What's your unfair advantage?
Time commitment?
From the answers, generate:
I help [TARGET AUDIENCE] [ACHIEVE WHAT] by sharing [YOUR UNIQUE ANGLE].
Examples:
Store this positioning. Every post must align with it.
Based on positioning, define 4-5 content pillars. These are the recurring themes all content falls under.
Phase 1: Educational (Days 1-30) Build trust through competence. Show what AI can do. Prove you know your stuff.
Phase 2: Personal (Days 30+) Once they trust your expertise, share your journey and opinions.
Why this order matters: Nobody cares about your story until they believe you're worth listening to. Competence first, connection second.
| Day | Pillar | Why |
|---|---|---|
| Monday | Concept Explainer | Start week with value, educational |
| Tuesday | Use Case | Concrete example, shows capability |
| Wednesday | Capability/Demo | Mind-blow moment, high save rate |
| Thursday | Use Case | Another concrete example |
| Friday | Honest Limitations | Trust-building through honesty |
Start mixing personal content at 20% of posts after Day 30, increasing gradually.
When the user wants content, follow this process:
Get the raw input from the user. This can be:
Select the best format (see formats below)
Write the post applying all LinkedIn optimization rules
Generate 3 variations with different hooks
Recommend posting time and hashtags
[Hook: surprising statement or number]
Here's what I learned after [X experience]:
1. [Point] — [1-2 line explanation]
2. [Point] — [1-2 line explanation]
...
7-10 points
[Closing question or call to action]
When to use: Technical tips, career advice, tool recommendations
Example hook: "I mass hired 47 engineers in 2 years. Here are 9 hiring red flags I now catch in the first 5 minutes:"
[Hook: Problem someone had]
[Who they were — 1 line]
[The problem — specific, relatable]
[What we built — simple explanation]
[How it works — 3-4 bullet points]
[The result — specific numbers]
[What this means for the reader]
[Question to the audience]
When to use: Showing AI solving real problems, building credibility, demonstrating capability
Example hook: "A coach asked me: 'Can AI help me respond to DMs faster?' Here's what we built in 3 hours:"
Note: Story format (personal failures, lessons) works better AFTER you've built trust through educational content. Save stories for Phase 2 (Day 30+).
[Hook: "Everyone says X. I disagree."]
[Why the common wisdom is wrong — 2-3 points]
[What's actually true — your argument]
[Evidence or experience backing your position]
[Invite debate: "Am I wrong? Tell me why."]
When to use: Industry opinions, technology debates, process challenges
Example hook: "Stop writing unit tests. Yes, I'm serious. Here's why 90% of unit tests are a waste of your team's time:"
[Hook: "How I [achieved result] using this simple framework:"]
[Name the framework — give it a memorable name]
Step 1: [Action] — [Why it works]
Step 2: [Action] — [Why it works]
Step 3: [Action] — [Why it works]
[Show result or outcome]
[Offer to share template/details in comments]
When to use: Processes, methodologies, decision-making approaches
Example hook: "I use a 3-question test before every architecture decision. It's saved me from 6 rewrites this year:"
[Hook: "X vs Y — here's what nobody tells you:"]
[Common perception]
[Reality based on your experience]
[When to use each]
[The nuanced answer most people miss]
When to use: Technology comparisons, career stages, approach trade-offs
Example hook: "Junior devs write code. Senior devs delete code. Here's the difference nobody explains:"
Slide 1: [Bold hook title — 5-8 words max]
Slide 2: [The problem — why this matters]
Slides 3-8: [One point per slide — visual, concise]
Slide 9: [Summary / key takeaway]
Slide 10: [CTA — follow for more, save this, share your take]
When to use: Complex topics, tutorials, visual concepts
Note: Generate as a PDF or use a design tool. Text-heavy slides work fine on LinkedIn — don't over-design.
[Term/concept] explained without the hype:
[Simple definition — 1-2 lines]
[Analogy that makes it click]
[Example of how it works in practice]
[What this means for non-technical people]
[When to care about this vs when to ignore it]
When to use: Demystifying AI terms, building credibility with non-technical audience
Example hook: "'AI Agents' explained without the jargon:"
Let's be honest about what AI [still can't do / gets wrong / overpromises]:
❌ [Limitation 1 — with brief explanation]
❌ [Limitation 2 — with brief explanation]
❌ [Limitation 3 — with brief explanation]
[Why this matters]
[What to do instead / the real answer]
[Balanced perspective that shows expertise]
When to use: Building trust by not overselling, differentiating from hype accounts
Example hook: "Let's be honest about what AI still can't do well:"
Every post generated by this skill follows these rules:
Never reveal sources. You are the authority, not a curator.
Never say:
Always say:
The goal: People should wonder "how does this person always know what's happening?" — never "oh they just read Twitter"
You consume information privately. You output original-sounding insight publicly. The pipeline is invisible.
When asked to generate a content calendar, create a week or month of planned posts:
For each day, provide:
Organize months around themes for coherence:
Content alone isn't enough. Provide these engagement instructions:
After 2 weeks, ask the user for their metrics:
| Metric | What It Means | Target (first 90 days) |
|---|---|---|
| Impressions | How many feeds your post appeared in | 1,000+ per post |
| Engagement rate | (Reactions + Comments) / Impressions | 3-5% |
| Profile views | People clicking to learn about you | 100+/week |
| Connection requests | People wanting to follow your work | 20+/week |
| DMs / Inbound | People reaching out for business | 2-5/month |
Every 2 weeks:
The user can trigger these at any time:
| Command | What It Does |
|---|---|
| "Generate a post about [topic]" | Creates 3 post variations with hooks, using best format for the topic |
| "Give me a week of content" | Generates 5 posts across all pillars with full details |
| "Give me a month calendar" | Creates a 4-week content plan with themes, topics, and hook drafts |
| "Rewrite this for LinkedIn" | Takes raw text/idea and reformats it as an optimized LinkedIn post |
| "Analyze this post" | Reviews a post (yours or someone else's) and explains what works/doesn't |
| "What should I post today?" | Suggests a topic based on current pillar rotation and trending themes |
| "Generate a carousel on [topic]" | Creates a 10-slide carousel outline with text for each slide |
| "Give me 10 hooks for [topic]" | Generates 10 hook variations ranked by expected engagement |
| "Help me respond to [comment]" | Crafts a reply that continues the conversation and boosts engagement |
When the user first invokes this skill, walk through this:
Store all positioning/pillar decisions so future content stays consistent.
User input: "I spent 3 days debugging a memory leak in production. Turned out it was a single line of code — an event listener that was never removed."
AI output:
Post (Story format):
I mass spent 72 hours hunting a memory leak.
Our Node.js service was eating 14 GB of RAM. Alerts firing every 4 hours. Team of 5 engineers digging through heap dumps.
The fix? One line:
element.removeEventListener('resize', handler)
An event listener registered in a useEffect — without a cleanup function.
3 days of engineering time. $15,000 in labor costs. 1 missing return statement.
Here's what I actually learned:
→ The bug wasn't the problem. Our lack of memory profiling in CI was. → We now run heap snapshots on every PR that touches event handlers. → The cheapest debugging is the debugging you never have to do.
Junior devs fix bugs.
Senior devs fix the system that let the bug happen.
What's the most expensive one-line fix you've ever shipped?
#SoftwareEngineering #Debugging #WebDevelopment #NodeJS
Variations:
Hook A (numbers-led): "1 line of code. 72 hours of debugging. $15,000 in engineering time."
Hook B (contrarian): "The most expensive code I've ever written was 47 characters long."
Hook C (direct address): "If you've ever spent 3 days debugging something that turned out to be 1 line — read this."
Recommended posting: Tuesday or Thursday, 8 AM (story format performs well mid-week)
Hashtags: #SoftwareEngineering #Debugging #WebDevelopment #NodeJS #TechLeadership
After the first 2 weeks of posting:
The system gets better the more data you feed it. Think of the first 2 weeks as calibration.
Once you have consistent engagement (usually 60-90 days):