Guides & checklists
AI Coding Resources & Checklists
Ten complete, specific checklists — not generic filler — covering AI coding, prompt engineering, git, launches, agents, APIs, security and SEO. Jump to any section below.
Jump to
Pick a checklist
AI Coding Checklist
What to do before, during and after an AI-assisted coding session.
Prompt Engineering Guide
A practical checklist for writing prompts that get useful, specific results.
Git Cheat Sheet
The commands you'll actually use daily, plus habits that prevent painful merges.
AI Development Checklist
Project-level basics for building a real application with AI assistance.
Website Launch Checklist
The pre-launch pass most sites skip and regret later.
SaaS Launch Checklist
What needs to work end-to-end before you announce publicly.
AI Agent Checklist
Guardrails to put in place before an agent gets to act on its own.
API Integration Checklist
Avoid the failure modes that only show up once real traffic hits.
Security Checklist
The baseline every project should meet, not an advanced-only concern.
SEO Checklist
On-page fundamentals that matter more than any trick.
AI Coding Checklist
What to do before, during and after an AI-assisted coding session.
- Write a clear, scoped task description with a definition of done before you prompt
- Point the tool at the specific files or directories relevant to the task, not the whole repo blindly
- Ask for a plan before letting it edit multiple files, and review the plan first
- Run the existing test suite before making changes to establish a baseline
- Review every diff line-by-line before committing — especially auth, payments and data handling
- Run your linter and type-checker on AI-generated code, don't just eyeball it
- Ask for tests covering the new behavior, not only the happy path
- Check for hard-coded secrets, API keys or credentials introduced by the change
- Commit in small, reviewable chunks rather than one giant AI-generated commit
- Don't ship code you can't explain — re-read anything you don't fully understand
Prompt Engineering Guide
A practical checklist for writing prompts that get useful, specific results.
- State the goal and the concrete output format you want up front
- Give explicit constraints — language/framework version, style guide, files not to touch
- Include relevant context: error messages, file snippets, existing patterns to match
- Ask for a plan first on multi-step tasks, then approve it before execution
- Specify what 'done' looks like — a passing test, a specific behavior, an example output
- Iterate with follow-up instructions instead of rewriting the whole prompt from scratch
- Ask the model to flag uncertainty or ambiguity rather than guessing silently
- Break large tasks into smaller, independently checkable steps
- Give a concrete input/output example when precision matters
- Say explicitly what NOT to do — e.g. 'don't change the database schema'
Git Cheat Sheet
The commands you'll actually use daily, plus habits that prevent painful merges.
Common commands
git status # see what's changed
git add <file> # stage a specific file
git commit -m "message" # commit staged changes
git push # push commits to the remote
git pull # fetch and merge remote changes
git branch # list branches
git checkout -b <name> # create and switch to a new branch
git merge <branch> # merge a branch into the current one
git log --oneline # compact commit history
git diff # see unstaged changes
git diff --staged # see staged changes before committing
git stash # temporarily shelve uncommitted changes- Write commit messages that explain why the change was made, not just what changed
- Commit small, logical chunks rather than one huge, unreviewable commit
- Pull before starting new work to avoid painful merge conflicts later
- Create a branch per feature or fix instead of committing directly to main
- Review your own staged diff before committing
- Never force-push to a shared branch without warning your team first
- Add a .gitignore for secrets, build output and dependency folders before your first commit
- Tag releases so you can find and roll back to a known-good state
AI Development Checklist
Project-level basics for building a real application with AI assistance.
- Define the product scope and core user flow before writing any code
- Choose a stack you can actually maintain, not just the trendiest option
- Set up version control and a basic CI check before the codebase grows
- Store secrets in environment variables from day one, never hard-coded
- Build the smallest working version of the core flow before adding features
- Add basic error handling and logging so failures are visible, not silent
- Write tests for critical paths — auth, payments, data writes — as you go
- Check AI-suggested dependencies for maintenance status and license before adding them
- Document setup steps so a new contributor, or future you, can run the project
- Plan a rollback strategy before your first production deploy
Website Launch Checklist
The pre-launch pass most sites skip and regret later.
- Test the site on mobile, tablet and desktop breakpoints, not just your dev monitor
- Check every internal link and form for broken paths or dead submissions
- Add unique meta titles, descriptions and Open Graph images to every page
- Verify the contact form actually delivers to an inbox someone checks
- Set up an SSL certificate and confirm HTTP redirects to HTTPS
- Add privacy-compliant analytics before launch, not after
- Create and submit an XML sitemap and a robots.txt
- Test page load speed and compress oversized images
- Set up 404 and error pages that actually help a lost visitor
- Confirm the favicon, browser tab title and social share previews look correct
SaaS Launch Checklist
What needs to work end-to-end before you announce publicly.
- Confirm signup, login, password reset and email verification all work end-to-end
- Test the billing flow with a real test transaction, including a failed payment
- Verify plan limits and upgrade/downgrade paths behave correctly
- Set up transactional emails — welcome, receipt, password reset — and test deliverability
- Add basic usage logging so you can see whether new users actually succeed
- Write terms of service, a privacy policy, and a refund/cancellation policy
- Set up monitoring and alerts for downtime or error spikes before you have real users
- Test what happens when a trial expires or a subscription is cancelled
- Confirm data export and deletion work for privacy compliance requests
- Have a support channel — even just a monitored email — live before you announce
AI Agent Checklist
Guardrails to put in place before an agent gets to act on its own.
- Define the specific goal and boundaries of what the agent is allowed to do
- List every external tool or system the agent needs, and scope permissions minimally
- Decide which actions require human approval versus which can run autonomously
- Log every action the agent takes, not just its final output
- Test the agent against edge cases and unexpected inputs, not only the happy path
- Build in a way to pause, override or shut the agent down manually
- Set rate limits or cost caps so a runaway loop can't cause unbounded damage
- Verify the agent handles a tool failure or bad API response gracefully, not silently
- Periodically review a sample of the agent's real actions, not just at launch
- Document what the agent does and doesn't do for anyone who has to support it later
API Integration Checklist
Avoid the failure modes that only show up once real traffic hits.
- Read the provider's authentication and rate-limit docs before writing any code
- Store API keys and secrets in environment variables, never in source control
- Handle failed requests, timeouts and rate-limit responses explicitly
- Validate and sanitize data coming back from the API before using it downstream
- Add retry logic with backoff for transient failures — never infinite retries
- Log request and response failures with enough detail to debug, without logging secrets
- Test against the provider's sandbox or test mode before touching production data
- Check the provider's versioning policy and pin to a specific API version
- Set a timeout on every external call so one slow API can't hang your whole app
- Monitor usage against the provider's quota so you're not surprised by a cutoff
Security Checklist
The baseline every project should meet, not an advanced-only concern.
- Never commit API keys, passwords or tokens to version control
- Hash passwords with a proper algorithm — never store them in plain text
- Validate and sanitize all user input on the server, not just the client
- Use parameterized queries to prevent SQL injection
- Enforce HTTPS everywhere, with redirects and HSTS
- Apply the principle of least privilege to database and API credentials
- Keep dependencies updated and monitor for known vulnerabilities
- Add rate limiting on login, signup and password-reset endpoints
- Set secure, httpOnly cookies for session tokens
- Have a plan for what happens if a key or credential leaks, including rotation
SEO Checklist
On-page fundamentals that matter more than any trick.
- Write a unique, descriptive title tag and meta description for every page
- Use one clear H1 per page that matches search intent
- Structure content with logical headings (H2/H3) rather than skipping levels
- Add descriptive alt text to meaningful images
- Keep the site fast and mobile-friendly (Core Web Vitals)
- Create and submit an XML sitemap to search consoles
- Use canonical tags to avoid duplicate-content issues
- Internally link related pages with descriptive anchor text
- Add structured data (schema.org) where relevant — articles, FAQs, products
- Avoid thin or duplicate content — each page should serve a distinct search intent
Ready to put a checklist into practice?
Pair these with a real project, a prompt from the library, or a tool built for the job.