Developer Education
Developer education designs and delivers learning experiences that help programmers adopt tools, APIs, or practices. It covers curriculum design, tutorial writing, workshop facilitation, and the feedback loops that measure whether learners can actually do the thing being taught.
itTechnical communication and collaboration | OpenSkills.info
Course pathWalk it in order
Look it upDip in anytime
Go furtherLeaves this page
Don't Panic
Don't Panic — Developer Education
Developer education is the work of turning a technical product into a path that lets a person do something real with it. Documentation can tell someone which parameter an API accepts. Education has the more demanding job of helping them know when to use it, what result to expect, and how to notice when the machine has wandered off to make tea instead.
The useful starting point is the learning gap: the distance between what a developer can do now and the task in front of them. This prevents the traditional response to a product question, which is to open every feature drawer at once and call the resulting avalanche “onboarding.” Choose one audience, one real task, and the prerequisite knowledge that makes that task possible.
Next comes an observable objective. “Understand pagination” is pleasant but hard to inspect. “Retrieve a second page and explain the cursor” gives the learner an action, gives the educator an assessment, and gives everyone a way to disagree productively about whether the lesson worked. The activity and the assessment must ask for the same capability. A recall question cannot prove that someone can diagnose a failed request, however confidently it is multiple choice.
Different information has different jobs. A tutorial manages a first learning experience and earns its keep with small steps, early success, and recovery from likely errors. A how-to guide serves a prepared person with a specific task. Reference supplies exact facts. Explanation supplies the reasons and tradeoffs. Combining all four into one enormous page is how a helpful path becomes a cupboard full of maps, none of which says where the door is.
The surprising part is that examples are not decorative. They are learning infrastructure. A sample needs a clean environment, required setup, visible output, clear placeholders, and a version someone has tested. If a learner cannot verify an important state change, the course has asked them to proceed on faith. Computers are quite fond of that arrangement. Learners should not be.
Start with the Intro for the full design model. Use Slides when the relationship among audience, objective, practice, feedback, and assessment needs a quick map. Keep the Cheatsheet nearby while reviewing a module. Then use the Practice Reference to design one path, test it from a clean state, and decide what evidence should change the next revision.
Where this skill leads
Relevant careers
See how this topic contributes to broader role-level skill maps.
Sources
- https://developers.google.com/tech-writing/overview
Supports
- Technical writing curricula for software engineers, students, and engineering-adjacent roles
- Pre-class material for introduction and instructor-led sessions for integration and practice
- Self-study and instructor-led delivery modes
- https://developers.google.com/tech-writing/one/audience
Supports
- Audience analysis based on roles, existing knowledge, technical proximity, and time since prior use
- Defining the tasks and knowledge an audience needs
- Matching vocabulary, explanations, and cultural context to the audience
- https://developers.google.com/tech-writing/one/documents
Supports
- Explicit scope, non-scope, audience, prerequisites, and intended outcomes
- Organizing content around audience needs and connecting new concepts to existing knowledge
- https://www.cdc.gov/training-development/php/about/design-training-learning-objectives.html
Supports
- Learning objectives as statements of knowledge, skill, or attitude gained through training
- Learner-centered, action-oriented, specific, achievable, and measurable objectives
- Alignment of objectives with content, activities, competencies, and assessment
- Progressive cognitive actions from recall through creation
- https://diataxis.fr/
Supports
- Tutorials, how-to guides, reference, and explanation as forms serving distinct user needs
- Documentation organization based on learning and working needs
- https://diataxis.fr/tutorials/
Supports
- Tutorials as learning-oriented practical experiences with meaningful action and achievable goals
- Small steps, early results, concreteness, and coherent end-to-end learning journeys
- Tutorial maintenance sensitivity when products change
- https://diataxis.fr/how-to-guides/
Supports
- How-to guides as goal-oriented directions for real work
- User goals rather than product operations as the organizing principle
- Separation of how-to guidance from tutorial teaching and reference detail
- https://diataxis.fr/reference/
Supports
- Reference as structured, factual technical description for consultation during work
- Product structure, consistency, accuracy, precision, completeness, and clarity in reference material
- https://diataxis.fr/explanation/
Supports
- Explanation as understanding-oriented context, connections, reasons, and alternatives
- https://developers.google.com/style/code-samples
Supports
- Readable code formatting, introductory statements, and language-specific conventions
- Marking omitted code with comments in the sample language
- https://developers.google.com/style/procedures
Supports
- Ordered, imperative, concise actions with context and goals
- Choosing an accessible procedure and avoiding duplicated procedures
- https://www.cdc.gov/training-development/php/qts/index.html
Supports
- Training quality standards spanning audience needs, objectives, relevant content, engagement, accessibility, assessment, evaluation, and improvement
- Assessment activities tied directly to objectives and realistic learner contexts
- Formative evaluation and learner feedback for ongoing quality improvement
- https://www.cdc.gov/training-development/php/about/evaluate-training-building-an-evaluation-plan.html
Supports
- Early evaluation planning around purpose, questions, stakeholders, and collection methods
- Process and outcome evaluation questions
- Use of evaluation findings to improve training and make resource decisions
- https://www.cdc.gov/training-development/php/about/evaluate-training-measuring-effectiveness.html
Supports
- Evaluation of learning and workplace learning transfer
- Pretraining and post-training assessment, in-course checks, immediate evaluation, and delayed follow-up
- Learner satisfaction as insufficient evidence of training effectiveness
- Delayed follow-up as a method for assessing application at work
- https://developers.google.com/style/accessibility
Supports
- Accessible headings, lists, procedures, links, images, code, and terminal output
- Equivalent text for visual information and captions or transcripts for recordings
- Avoiding images of text, code samples, and terminal output
- https://www.w3.org/WAI/tutorials/
Supports
- Task-based accessibility tutorials for developers, designers, trainers, authors, and project managers
- Guidance grounded in WCAG success criteria and techniques
- Accessible images, tables, forms, page structure, menus, and carousels
- https://docs.github.com/en/contributing/writing-for-github-docs/best-practices-for-github-docs
Supports
- Matching documentation to an identified audience, core task, and content type
- Placing information in the order readers need it and separating nonessential material
- https://docs.github.com/en/contributing/style-guide-and-content-model/quickstart-content-type
Supports
- Quickstarts are for focused tasks when readers already understand the product, while more complex learning needs a tutorial
- Quickstarts state audience, prerequisites, an outcome, and links to next steps
- https://developers.googleblog.com/teaching-the-art-of-great-documentation/
Supports
- Google technical-writing courses combine self-study, facilitated sessions, practical exercises, discussion, and peer feedback
- Audience awareness is a central writing exercise for developers
- https://www.gitbook.com/solutions/public-docs
Supports
- GitBook provides collaborative publishing for public product documentation
- https://readme.com/
Supports
- ReadMe provides a hosted developer-hub and API documentation product
- https://www.mintlify.com/docs/quickstart
Supports
- Mintlify supports repository-based documentation that is deployed as a documentation site
- https://docusaurus.io/docs/create-doc
Supports
- Docusaurus documentation is authored as files and organized into a documentation-site structure
- https://buildwithfern.com/
Supports
- Fern provides developer-documentation tooling for API products
