Turn your code into content.
Devlog is an AI-powered developer growth platform that automatically converts GitHub development activity into a clean development timeline and high-quality social media content.
Getting Started · Features · Architecture · Roadmap · Contributing
Devlog is built for:
- Indie founders & solo SaaS builders who want to share their journey without spending hours writing content.
- Open-source maintainers who want a clear development log and occasional public updates.
- Privacy-conscious teams who want internal documentation of progress without leaking core IP.
Many developers want to build in public or simply keep a clean record of what they ship, but struggle with:
- Consistently writing updates
- Adapting posts for different platforms
- Maintaining social presence while coding
- Turning technical progress into engaging content
- Keeping sensitive details and proprietary work private
Devlog analyzes your commits, pull requests, releases, and milestones — then automatically generates platform-optimized posts for X (Twitter), LinkedIn, Reddit, Indie Hackers, and developer blogs.
Git commit → AI analysis → content generation → scheduled posting
Build in public effortlessly. Stay focused on shipping product.
Connects directly to your GitHub repository and monitors commits, pull requests, issues, releases, and milestone completions. The system focuses on meaningful product progress, not raw code diffs – similar to how good bloggers or writers share outcomes and lessons rather than implementation details.
Commit: "Implemented startup scoring algorithm"
AI Output: Feature milestone detected — new product capability added
Generated: Day 14 building my AI startup validator.
Just shipped the scoring engine.
The system now evaluates ideas across:
• Market size
• Competition
• Founder advantage
• Execution complexity
Each detected event generates posts for multiple platforms with tone-optimized content.
| Platform | Style |
|---|---|
| X (Twitter) | Concise threads, hook-driven |
| Professional storytelling | |
| Community discussion | |
| Indie Hackers | Founder narrative |
| Dev.to / Hashnode | Technical blog format |
| Product Hunt | Launch update (planned) |
Review and edit generated posts before publishing:
- Rich text editing with markdown support
- Tone adjustment and AI regeneration
- Image generation support
- Thread splitting for X
Publish to multiple platforms simultaneously with supported integrations:
- X API · LinkedIn API · Reddit API · Dev.to · Hashnode
- Publish instantly, schedule posts, or create content queues
Two complementary views over your work:
- Dev Timeline – a smooth, interactive timeline of your commits, PRs, and milestones so you can review your build journey at a glance (even if you never post publicly).
- Content Calendar – a visual calendar for scheduling content with drag-and-drop, multi-platform visibility, queue system, and recurring updates.
Example schedule:
Mon — Private devlog entry
Wed — Public feature update
Fri — Build in public thread
Per-repo privacy levels so you stay in control:
- High privacy – uses commit messages and high-level summaries only, no code or implementation details in generated text.
- Medium – describes behavior and impact without exposing sensitive internals (no file paths or algorithm details).
- Low – best for open-source / public marketing; allows more specific feature mentions and links.
Devlog never auto-posts without your review. You decide how much detail is revealed and where it is shared.
Devlog is opinionated about what “good sharing” looks like. Inspired by creators like Zen Habits and personal bloggers, it focuses on:
- Outcomes shipped (what changed for users)
- Lessons learned (what you discovered)
- Visible progress over time
instead of exposing sensitive code or internal implementation details. You can choose to share aggregated stats and high-level summaries rather than specific changes.
Track content performance across platforms — engagement rate, follower growth, post impressions, and best performing content. Understand what posts attract users, what drives engagement, and which platforms work best.
Devlog aims to become the developer distribution engine.
GitHub → AI growth engine → audience → customers
Help developers grow audiences, acquire early users, build communities, and launch products.
┌──────────────────┐
│ GitHub API │
└────────┬─────────┘
│
▼
┌────────────────────────┐
│ Event Detection │
│ (commit analysis) │
└───────────┬────────────┘
│
▼
┌────────────────────────┐
│ AI Content Engine │
│ (LLM prompt pipeline) │
└───────────┬────────────┘
│
┌─────────────┴─────────────┐
│ │
▼ ▼
┌──────────────────┐ ┌──────────────────┐
│ Content Editor │ │ Content Calendar │
└────────┬─────────┘ └────────┬─────────┘
│ │
▼ ▼
┌──────────────────────────────────────┐
│ Multi-Platform Publishing System │
└──────────────────────────────────────┘
Devlog is built on a modern, industry-standard web stack that’s common across SaaS dashboards and developer tools.
| Layer | Technology | Purpose |
|---|---|---|
| Frontend | Next.js 14 (App Router), React 18, TypeScript, Tailwind CSS, Geist font, Framer Motion | Modern, responsive dashboard UI, timeline, content editor, analytics, and calendar interactions |
| Styling | Tailwind CSS, clsx, tailwind-merge, class-variance-authority, lucide-react |
Dark-mode design system, variant-based components, utility composition, and icons |
| Backend | Next.js Route Handlers, TypeScript | GitHub webhook handling, event processing, AI orchestration, API routing, and platform integrations |
| AI | OpenAI API, Anthropic API, local model support (planned) | Commit summarization, outcome-focused narrative, multi-platform post generation, and tone adaptation |
| Database | PostgreSQL + Prisma | Users, repositories, events, generated posts, privacy settings, and analytics |
| Queue | Redis, BullMQ (or equivalent) | Background AI job processing, scheduled posts, and event pipelines |
| Infra | Vercel, Railway / Fly.io, Supabase/Neon, Cloudflare | Frontend hosting, backend services, managed Postgres, auth, and edge security |
Python and FastAPI are also strong candidates for AI-heavy backend components in the future, but the initial product surface is optimized around the React + TypeScript + Next.js ecosystem that most modern dev tools use.
- Node.js 18+
- A GitHub OAuth App (for “Sign in with GitHub”)
- SQLite is used by default for local development (no Postgres required to start). Redis/Postgres remain optional for future features.
# Clone the repository
git clone https://github.com/yourusername/devlog
cd devlog
# Install dependencies
npm install
# Configure environment variables
cp .env.example .env.localAdd your keys to .env.local at minimum:
DATABASE_URL="file:./prisma/dev.db"
GITHUB_CLIENT_ID=
GITHUB_CLIENT_SECRET=
NEXTAUTH_SECRET= # e.g. openssl rand -base64 32
NEXTAUTH_URL=http://localhost:3000In your GitHub OAuth App, set Authorization callback URL to:
http://localhost:3000/api/auth/callback/github
# Create / update the local database
npx prisma migrate dev
# Start development server
npm run devThe app will be available at http://localhost:3000.
1. GitHub webhook triggers
2. Event stored in database
3. AI analyzes commit
4. AI generates platform-specific posts
5. User reviews and edits content
6. Post scheduled or published
Devlog uses a simple, fast Git branching model optimized for solo builders and small teams.
main– always-deployable, stable branch. Production deployments should come frommain.feature/*– short-lived branches for specific pieces of work (features, fixes, experiments).
# Create a new feature branch from main
git checkout main
git pull origin main
git checkout -b feature/dev-timeline-ui
# Commit your work on the feature branch
git commit -am "feat: add basic dev timeline layout"
# Push and open a pull request back into main
git push origin feature/dev-timeline-uiGuidelines:
- Keep changes on
feature/*branches focused and small. - Use descriptive branch names like
feature/github-integration,feature/privacy-settings,feature/dev-timeline-ui. - Merge into
mainonly when the feature is tested locally and does not break the app.
This keeps main clean for deployments while preserving a clear history of feature work that Devlog itself can later turn into timeline entries and posts.
Devlog currently uses a single-app structure optimized for fast iteration, with a clean path to a future monorepo split if the backend grows significantly.
docs/ architecture, API contracts, decision records, agent coordination
src/app/ Next.js routes and route handlers
src/components/ reusable UI components
src/features/ feature-level domains (github, timeline, privacy, post generation, etc.)
src/lib/ shared helpers and infrastructure clients
src/server/ server-only services, repositories, jobs, and schemas
src/styles/ global styles
src/types/ shared application types
prisma/ database schema and migrations
scripts/ local automation scripts
tests/ unit and integration tests
.github/workflows/ CI and automation workflows
Every feature/* branch must update docs/agent-worklog.md in its first meaningful commit so each implementation chat can quickly understand:
- what branch is active,
- what area is being changed,
- what files are expected to be touched,
- and whether the work depends on any API or data model changes.
Supporting docs:
docs/CHANGELOG.md— dated milestones (start here for “what changed when”)docs/architecture.mddocs/api-contracts.mddocs/agent-worklog.mddocs/decisions/
Last updated: Mar 19, 2026 ·
v0.1.0· merged intomain
| Area | Status | Notes |
|---|---|---|
| Landing page | ✅ Done | Hero, features grid, pricing CTA |
| App shell | ✅ Done | Sidebar, Topbar, route-group layout |
| Dashboard | ✅ Prototype | Static placeholder data |
| Dev Timeline UI | ✅ Done | Fully componentized, fake data, live search + type filter |
| Settings page | ✅ Prototype | UI shell only |
| GitHub integration | 🟡 In Progress | OAuth connect, repo picker, commit fetch (no webhooks yet) |
| AI post generator | 🔲 Planned | LLM prompt pipeline |
| Content editor | 🔲 Planned | Rich text, tone adjustment |
| Multi-platform publishing | 🔲 Planned | X, LinkedIn, Reddit, Dev.to |
| Content calendar | 🔲 Planned | Scheduling, drag-and-drop |
| Analytics | 🔲 Planned | Engagement metrics, growth tracking |
The first release will include:
- GitHub repo integration (OAuth + webhook)
- Commit / PR / release event detection
- AI post generator (OpenAI / Anthropic)
- X + LinkedIn publishing
- Content editor with tone adjustment
- Post scheduling
Estimated build time from current state: 5–10 days
GitHub integration, AI post generator, multi-platform scheduling.
Analytics dashboard, content strategy AI, viral post prediction, audience discovery.
Community features, developer leaderboard, automatic devlogs, visual content generation (screenshots, mockups, diagrams).
Devlog will use simple semantic versioning to mark meaningful product stages.
- GitHub OAuth + repo selection for a single user.
- Basic event capture from commits and/or pull requests.
- Simple internal-only dev timeline UI with fake or minimal AI summaries.
- No external users yet, used only by the maker to test core workflows.
- Reliable GitHub event ingestion for selected repos.
- AI-generated summaries for meaningful events (commit/PR → outcome-focused text).
- Editable dev timeline entries and a first version of privacy levels (e.g., high vs medium).
- Ability to generate draft posts for at least reddit, maybe X and LinkedIn.
- Onboarding that a small group of external testers can complete without hand-holding.
- Stable GitHub integration with clear error handling and status.
- Polished dev timeline and content calendar suitable for daily use.
- Mature privacy controls, documented and easy to understand.
- Multi-platform post generation with tone presets (X, LinkedIn, Reddit at minimum).
- Basic analytics (consistency and top-performing posts) and a simple paid plan.
- Public landing page, documentation, and GitHub release tagged
v1.0.0.
Devlog will ship with a simple, pragmatic pricing model designed to balance adoption and sustainability.
- 1 repo connected
- Very limited monthly generation (e.g. 10–20 events/posts per month)
- No scheduling / calendar
- Optional “Made with Devlog” watermark
- Unlimited (or high-cap) generation
- Scheduling + content calendar
- Tone presets + platform templates
- Multi-platform workflows and publishing improvements
- No trial required initially, or a short Pro trial after a user is activated (e.g. after generating their first posts).
- If Devlog can reliably deliver a “first post in <2 minutes” experience, a 7-day Pro trial may be used instead of a permanent free tier.
| Feature | Description |
|---|---|
| AI Growth Strategy | AI suggests what to post, when to post, and content themes |
| Viral Post Generator | Predicts virality score and engagement potential |
| Founder Leaderboard | Public ranking by consistency, engagement, and growth |
| Automatic Devlogs | AI-generated weekly progress reports |
| Visual Content Generation | Feature screenshots, product mockups, diagrams |
| Audience Discovery | Identify potential users by interest, engagement, and topic relevance |
| Devlog → Docs Integration | Export timeline entries into long-form documentation (e.g. wiki-style pages) for design notes, changelogs, and internal knowledge bases |
No. Devlog is designed with privacy-first controls. You can configure per-repo privacy levels so that content is generated from high-level summaries rather than raw code, and nothing is ever auto-posted without your explicit review and approval.
No. Devlog supports an internal-only mode where it acts as a private development journal and interactive timeline. You can use it solely to document your build journey and export summaries, even if you never publish to any social platform.
Each platform can use a different tone and framing. For example, Reddit-focused posts are generated in a feedback-seeking, non-promotional style (“Here’s what I built today, would love feedback”) while X and LinkedIn posts can be more announcement- or story-driven. Tone presets and platform-specific modes help keep your brand authentic instead of spammy.
Contributions are welcome. See CONTRIBUTING.md for guidelines.
# Fork the repository
# Create your feature branch
git checkout -b feature/your-feature
# Commit your changes
git commit -m "Add your feature"
# Push and open a pull request
git push origin feature/your-featureAreas where we need help:
- Platform integrations
- AI prompt engineering
- UI/UX improvements
- Analytics pipelines
This project is licensed under the MIT License.
Built by developers who believe distribution is as important as code.
If you find this project useful, please consider giving it a star.