Software engineering
22 entries tagged subject Software engineering.
- Engineering standards for an AI-native org Learn the standards floor that governs every repository in an AI-native estate: the floor rules, naming, commits and versioning, testing and quality, API design, configuration, secure SDLC, CI/CD, and observability and reliability. By the end you'll be able to make changes that pass the org gates by default. Cogitave's own standards are the worked example throughout.
- Onboard to an AI-native codebase The fast start for everyone joining an AI-native codebase: apply the non-negotiable floor every human and agent obeys, inherit a repository's complete ruleset through the project baseline, work the propose-only request lifecycle, and open your first signed, Conventional-Commit pull request. This is the Tier-0 entry point every role track builds on. Cogitave's own codebase is the worked example throughout.
- Patterns and golden paths Learn to build reuse-first: discover before you generate, start from a patterns catalog, inherit a repository's complete ruleset through the project baseline, and use decision guides for database, infrastructure, and model selection. By the end you'll reach for the named artifact before writing anything new. Cogitave's own patterns catalog is the worked example throughout.
- Design and version an API Shape a clean, consistent API against a clear API design standard - resources, standard methods, typed errors, cursor pagination, idempotency - then version and deprecate it under a versioning policy so no consumer is ever broken without consent.
- Apply the naming standards Name a new identifier, file, repo, or branch the way an AI-native org does - keyword-first, no redundant prefix, cased by role - and tell a functional keyword apart from a product codename, so your first artifact passes the naming gate by default.
- Apply a non-negotiable floor An AI-native org runs on a small floor every human and agent obeys. Study Cogitave's floor - its seven non-negotiable rules and what enforces each, from a commit-msg hook to policy-as-code - then apply a floor like it to your own first change.
- Read the pipeline that ships your change Follow a change from a pull request through the canonical CI stage set to a gated production deploy - the ordered gates a pipeline runs, why CI is the real gate, and how the deployment model promotes one signed artifact dev to staging to prod.
- Commits and versioning Write Conventional Commits whose type, scope, and breaking marker drive Semantic Versioning; see how release-please turns merged commits into a human-approved Release-PR, changelog, and tag; and how the trunk-based, protected-main model gates every release.
- Manage configuration and secrets Classify every value as a constant, a deployment parameter, or a secret; load configuration through the standard precedence chain, parsed once and fail-closed; and keep secrets out of git by referencing them at runtime and committing only encrypted-at-rest .env files.
- The one-model architecture Explain why an AI-native organization runs on one canonical property graph that humans and agents both query, what its node/edge model and identity scheme look like, and why a labeled property graph is the right substrate. Cogitave's Core is the concrete example.
- Inherit the project baseline How a new repository is born on the paved road with its whole ruleset already inherited, how to tell always-on standards from the ones a product type pulls in, and how to find an existing pattern before writing anything new.
- A native MCP interface to the canonical model Read a canonical model's native MCP interface as the source of truth for how humans and agents query one org's estate - why the surface is native rather than adapted, the protocol contract it commits to, and the tools and resources you call. Cogitave's Core is the worked example.
- Navigate the patterns catalog Find the canonical answer to "how does your org do X" in a patterns catalog, read an entry's five fixed sections without confusing the pointer for the policy, and run the discover-before-you-build loop so you start every new piece of work from a named artifact instead of a blank file.
- Observability and reliability Instrument a service with OpenTelemetry-spec traces, metrics, and logs, understand why agent traces are kept as evidence, and reason about reliability through SLIs, SLOs, error budgets, and the policy that turns a spent budget into a release freeze.
- Open your first pull request Apply an AI-native org's floor, its inherited baseline, and the request lifecycle in one hands-on contribution - a signed, Conventional-Commit, docs-complete pull request that passes the gates and stops for human review.
- Project products into the canonical model See how content projects into one canonical model as typed, content-addressed nodes rather than separate silos - Cogitave's Core is the worked example - and how the fact registry's cite-not-restate rule and fact-drift scanner keep one owner per fact across your estate.
- Query your canonical model Learn how a query layer resolves a request against one canonical graph - lexical BM25 and dense HNSW vectors fused by Reciprocal Rank Fusion, a graph-aware rerank and ranking signals, and a bounded, read-only profile agents call directly. Cogitave Query is the reference implementation you'll trace.
- Reuse-first engineering Explain why AI-assisted development diverges without a counter-force, state the discover-before-generate hard rule and what enforces it, and justify a from-scratch decision the way ADR-0003 requires - as a reasoned exception, not a default.
- Build with the secure SDLC State the security baseline - threat modeling, least privilege, and IAM - and follow the secure development lifecycle that shifts security left, so each stage of a change carries its own security gate instead of a check bolted on at the end.
- Test to the standard and pass the quality gate Learn how an AI-native org tests a change - the pyramid/trophy shape, the diff-coverage and mutation gates, flaky-test quarantine, the runnable harness, and the craftsmanship review bar - so you can test your own change and get it through the gate.
- Use the decision guides Learn the shared shape behind an AI-native org's database-selection, infrastructure-selection, and model-selection guides - a default, a decision tree, and an ADR-gated deviation rule - and walk a real workload to a justified, recorded choice.
- Work the request lifecycle Move a change through the seven-stage request lifecycle, understand why the write tools only propose, and read the Definition of Done that decides when a request is actually done rather than merely worked on.