Writing code remains an objective activity.

You write, run, test.

If there is a bug, it shows up.

If it works, it goes to production.

Now try explaining that exact same solution in a meeting.

In a few minutes, a relatively simple implementation can be covered by a layer of slide decks, buzzwords, frameworks, alignments, ceremonies, and terms that add volume to the conversation, but almost nothing to the software.

The curious thing is that programming continues to follow the same rules as always. Corporate communication, on the other hand, seems to invent new rules every week.

Today, in many companies, talking about technology has become harder than building technology.

Code remains the simple part

The computer does not interpret intentions.

It does not try to figure out what you meant.

It doesn't care about your job title.

It doesn't care about internal politics.

Much less about pretty presentations.

It simply executes instructions.


if user.is_authenticated:
    allow_access()

If an error exists, it pops up.

If it doesn't exist, the program proceeds.

This predictability is one of software engineering's greatest strengths.

The computer demands precision.

Meanwhile, a meeting can end after an hour without anyone being able to answer a simple question:

After all, what exactly are we going to build?

The problem is no longer technical

The tools have never been better.

Creating an API takes minutes.

Spinning up containers has become routine.

CI/CD pipelines are practically standard.

Provisioning infrastructure has gotten increasingly automated.

Even complex tasks can be accomplished with just a few lines of code.

The curious thing is that explaining this same implementation can consume days.

Not because it is difficult.

But because the conversation goes through presentations, alignments, validations, approvals, and discussions that rarely alter the technical solution.

Implementation stopped being the bottleneck.

Communication became the bottleneck.

When words replace information

Every field has its vocabulary.

In engineering, that makes sense.

Technical terms exist to reduce ambiguity.

The problem appears when they stop explaining anything.

It is common to hear phrases like:

  • "We need to evolve our digital maturity."
  • "Let's leverage this initiative."
  • "We need to operationalize this strategy."
  • "This solution creates more synergy."
  • "We need to accelerate our AI transformation."

After several minutes of discussion, it is still unclear:

  • What problem actually exists?
  • What will be built?
  • Who will do it?
  • How will we know it succeeded?

The more abstract the language, the lower the amount of useful information usually is.

The inflation of AI buzzwords

Artificial Intelligence brought important advances to engineering.

It also created a curious side effect.

Every week a new term is born that seems indispensable.

A few examples:

  • AI First
  • AI Native
  • AI Readiness
  • Agentic AI
  • Multi-Agent Systems
  • AI Orchestration
  • Prompt Engineering
  • AI Governance
  • AI Transformation

All of these concepts have technical context.

The problem starts when the name becomes more important than the result.

The conversation stops answering simple questions like:

  • What problem are we solving?
  • Is there a measurable gain?
  • Does the user notice any difference?
  • How much does it cost to maintain this?
  • Is there a simpler solution?

Without these answers, all that remains is a collection of fancy names.

Frameworks organize processes. They don't write software.

Whenever a process has issues, there is an almost automatic tendency in companies:

Add another process.

More documents.

More approvals.

More templates.

More meetings.

More metrics.

More ceremonies.

All of this can improve organization.

None of these things, on their own, deliver software.

Frameworks are tools.

Tools still depend on people who solve problems.

The invisible cost of meetings

Imagine a team of eight developers.

A one-hour meeting consumes eight engineering hours.

Two meetings a day represent sixteen hours.

In one week, practically two professionals worked exclusively watching meetings.

That is without considering:

  • constant context switching;
  • loss of focus;
  • time needed to regain previous train of thought;
  • decisions that could fit in a single direct message.

This cost rarely shows up on key performance indicators.

But it shows up in delivery deadlines.

In many projects, implementing takes less time than discussing

A common situation inside tech teams:

Activity Time
Solution discussion 3 hours
Alignment meetings 5 hours
Internal approvals 2 days
Implementation 2 hours
Deployment 10 minutes

Not every project is simple.

Critical architectures truly require planning.

The problem arises when a small change goes through the exact same bureaucratic path as a structural overhaul.

Clarity has become a technical differentiator

There is a curious perception about seniority.

Many people associate experience with sophisticated jargon.

In practice, the exact opposite happens.

Someone who truly masters a subject usually needs fewer words.

Compare these two explanations:

Corporate version
We need to revisit our authentication strategy to leverage our security posture and elevate operational maturity.
Engineering version
We're moving validation to the backend because currently it can be bypassed on the client side.

Both speak about the same topic.

One explains.

The other just takes up space.

AI accelerated text generation. Not clarity.

Large language models can produce massive documents in seconds.

That is useful.

But writing was never the biggest challenge.

The real challenge remains organizing ideas.

Today it has become extremely easy to generate twenty pages.

It remains hard to find the single important decision hidden inside them.

Producing more text never meant producing more information.

The true role of a senior professional

There is a skill that rarely appears in job descriptions.

Reducing complexity.

A good professional can look at a complicated problem and explain the solution simply.

They eliminate noise.

Avoid unnecessary terms.

Ask direct questions.

Document only what truly needs documenting.

Communication speeds up development instead of delaying it.

This is a far more valuable trait than knowing the trendiest framework or memorizing dozens of acronyms.

Conclusion

Languages have improved.

Compilers got faster.

Frameworks matured.

Tools automated tasks that used to take hours.

Engineering evolved.

Even so, many organizations manage to turn a two-hour change into weeks of discussions.

The problem is rarely in the code.

Most of the time, it's in the volume of noise created around it.

In the end, the computer remains the most objective team member.

It doesn't understand buzzwords.

It doesn't participate in alignment meetings.

It doesn't request a meeting to validate strategy.

It simply executes exactly what it received.

Perhaps there is a lesson in that.

The closer our communication gets to that level of objectivity, the more time is left for what truly matters: building software.

If you open job descriptions today, you'll be greeted by a suffocating list of terms:

Click here to see 500 jargon terms pushed on us every day...

PySpark, Hadoop, Scrum, Kanban, Agentic AI, CI/CD, Kubernetes, FinOps, Observability, GraphQL, Kafka, Redis, Terraform, Ansible, Prometheus, Grafana, Microservices, Serverless, Event-Driven, DDD, TDD, BDD, SAFe, OKR, DevOps, DevSecOps, MLOps, LLMOps, Vector DBs, RAG, Prompt Engineering, Docker, Helm, Istio, OpenTelemetry, ETL, ELT, Data Lakehouse, Snowflake, Databricks, PostgreSQL, DynamoDB, WebSockets, gRPC, JWT, OAuth2, Feature Flags, Blue-Green Deployment, Chaos Engineering, WebAssembly, Rust, Python, Go, TypeScript, Node.js, React, Next.js, Vue, Angular, Tailwind, Svelte, Fastify, Django, Flask, FastAPI, Spring Boot, ASP.NET Core, Laravel, Rails, Elixir, Phoenix, Kotlin, Swift, Flutter, React Native, RabbitMQ, ActiveMQ, AWS, Azure, GCP, Cloudflare, Vercel, Netlify, DigitalOcean, Linode, OpenShift, Rancher, ArgoCD, Flux, Jenkins, GitHub Actions, GitLab CI, Bitbucket Pipelines, SonarQube, Snyk, Datadog, New Relic, Dynatrace, ElasticSearch, Logstash, Kibana, Splunk, Jaeger, Zipkin, ClickHouse, Cassandra, MongoDB, Neo4j, Redis Enterprise, Supabase, Firebase, Prisma, TypeORM, Hibernate, SQLAlchemy, Pandas, NumPy, Scikit-Learn, TensorFlow, PyTorch, Hugging Face, LangChain, LlamaIndex, Ollama, vLLM, DeepSpeed, Triton, CUDA, OpenCL, WASM, WebGPU, Systemd, Linux, Nginx, Apache, Caddy, HAProxy, Envoy, Traefik, Kong, Apigee, Postman, Insomnia, Swagger, OpenAPI, Service Mesh, Sidecar, Circuit Breaker, Saga Pattern, CQRS, Event Sourcing, Distributed Tracing, Zero Trust, IAM, SSO, SAML, OIDC, TLS, mTLS, VPN, VPC, Subnet, CIDR, BGP, DNS, CDN, Edge Computing, Fog Computing, Serverless Framework, Terraform Cloud, Pulumi, Crossplane, Backstage, Backlog, Sprint Planning, Daily Standup, Retrospective, Refinement, Poker Planning, Velocity, Burndown, WIP Limits, Lead Time, Cycle Time, Cumulative Flow, Agile Coach, Scrum Master, Product Owner, Tech Lead, Staff Engineer, Principal Engineer, Engineering Manager, Solution Architect, Enterprise Architect, Cloud Architect, Data Engineer, Analytics Engineer, Data Scientist, ML Engineer, AI Engineer, Platform Engineer, Site Reliability Engineer (SRE), QA Automation, Performance Tester, Security Engineer, Penetration Tester, FinOps Analyst, Apache Spark, Apache Flink, Apache Storm, Apache Beam, Hive, Presto, Trino, Dremio, Delta Lake, Apache Iceberg, Hudi, Airflow, Prefect, Dagster, dbt, Luigi, NiFi, Kafka Connect, Debezium, Vector, Fluentd, Fluent Bit, Telegraf, VictoriaMetrics, Thanosis, Cortex, Loki, Tempo, OpenZipkin, OpenTracing, AppDynamics, Elastic APM, Honeycomb, Lightstep, Bugsnag, Sentry, Rollbar, LogRocket, Mixpanel, Amplitude, Segment, PostHog, RudderStack, Heap, FullStory, LaunchDarkly, Split, Flagsmith, Unleash, Optimizely, VWO, Google Analytics, Tag Manager, Hotjar, Clarity, Web Vitals, Lighthouse, PageSpeed, Core Web Vitals, SSR, SSG, ISR, Hydration, Resumability, Progressive Web Apps, Single Page Applications, Jamstack, Microfrontends, Shadow DOM, Web Components, Custom Elements, Virtual DOM, Reconciliation, Fiber, Signals, State Management, Redux, Zustand, Recoil, Jotai, MobX, Vuex, Pinia, RxJS, Observables, Event Loop, Non-Blocking I/O, Async/Await, Futures, Promises, Threads, Coroutines, Green Threads, Worker Threads, Web Workers, Service Workers, Shared Workers, WASI, Emscripten, AssemblyScript, Zig, Nim, D, Crystal, Haskell, Clojure, Scala, F#, OCaml, Erlang, R, Julia, MATLAB, Perl, Bash, Zsh, Fish, Powershell, Batch, VBScript, Lua, Solidity, Vyper, Move, Substrate, Web3, Smart Contracts, DApps, DAO, DeFi, NFT, IPFS, Arweave, Blockchain, Ethereum, Bitcoin, Solana, Avalanche, Polygon, Polkadot, Cosmos, Chainlink, Oracle, Zero-Knowledge Proofs, ZK-Rollups, Optimistic Rollups, Layer 2, Sharding, Consensus, Proof of Work, Proof of Stake, Raft, Paxos, Byzantine Fault Tolerance, Distributed Systems, CAP Theorem, PACELC Theorem, BASE Consistency, ACID Transactions, Eventual Consistency, Read Replicas, Write Ahead Log, Two-Phase Commit, Saga Orchestration, Saga Choreography, Outbox Pattern, Change Data Capture, Dead Letter Queue, Message Broker, Event Bus, Pub/Sub, AMQP, MQTT, STOMP, CoAP, WebRTC, Socket.IO, Long Polling, Server-Sent Events, HTTP/2, HTTP/3, QUIC, TCP, UDP, IP, ICMP, ARP, BFD, OSPF, ISIS, MPLS, SD-WAN, Network Function Virtualization, Software Defined Networking, eBPF, XDP, Kernel bypass, DPDK, RDMA, InfiniBand, NVMe-oF, Ceph, GlusterFS, MinIO, AWS S3, Azure Blob, Google Cloud Storage, EBS, EFS, Storage Gateway, RAID, ZFS, Btrfs, Ext4, XFS, LVM, Swap, Memory Management, Garbage Collection, Reference Counting, ARC, Borrow Checker, Ownership, Lifetimes, Memory Leaks, Buffer Overflow, Heap Allocation, Stack Allocation, Cache Invalidation, LRU Cache, LFU Cache, Write-Through, Write-Back, Cache Aside, CDN Edge, Varnish, Squid, CDN Invalidation, DNS Propagation, Anycast, GeoDNS, BGP Anycast, Load Balancing, Round Robin, Least Connections, IP Hash, Health Checks, Sticky Sessions, SSL Termination, Ingress Controller, Gateway API, Egress Gateway, Service Discovery, Consul, Etcd, ZooKeeper, Eureka, Sentinel, Vault, KMS, HSM, Secrets Manager, Sealed Secrets, SOPS, Bitnami Sealed Secrets, Cert-Manager, Let's Encrypt, ACME, Public Key Infrastructure, X.509, SSH Keys, GPG, PGP, JWT Validation, RSA, ECC, AES, ChaCha20, Argon2, Bcrypt, Scrypt, SHA256, HMAC, OWASP Top 10, SQL Injection, XSS, CSRF, SSRF, RCE, LFI, RFI, CORS, Content Security Policy, Security Headers, Rate Limiting, DDoS Protection, WAF, IPS, IDS, SIEM, SOAR, XDR, EDR, NDR, Zero-Day, CVE, CVSS, SAST, DAST, IAST, SCA, Threat Modeling, STRIDE, DREAD, Compliance, SOC2, HIPAA, GDPR, LGPD, PCI-DSS, ISO27001, NIST, CIS Benchmarks, Audit Logs, Least Privilege, Role-Based Access Control, Attribute-Based Access Control, Policy as Code, OPA, Kyverno, Gatekeeper, Checkov, Tfsec, Terrascan, Kube-bench, Kube-hunter, Trivy, Clair, Anchore, Grype, Syft, Container Security, Image Scanning, Distroless, Multi-stage Builds, Pod Security Standards, Network Policies, Service Account, Pod Disruption Budget, Horizontal Pod Autoscaler, Vertical Pod Autoscaler, Cluster Autoscaler, Karpenter, KEDA, Serverless Autoscale, Cold Starts, Edge Functions, Cloudflare Workers, AWS Lambda, Azure Functions, Cloud Functions, Vercel Edge, Netlify Functions, Knative, OpenFaaS, OpenWhisk, Serverless Framework, SAM, CDK, CloudFormation, Bicep, ARM Templates, Infrastructure as Code, Configuration Management, Drift Detection, Immutable Infrastructure, GitOps, Weave Flux, Argo Workflows, Tekton, Spinnaker, Octopus Deploy, Bambu, TeamCity, CircleCI, Travis CI, AppVeyor, Drone, Woodpecker, CodePipeline, CodeBuild, Renovate, Dependabot, Greenkeeper, Semantic Release, Conventional Commits, Git Flow, GitHub Flow, Trunk Based Development, Feature Branching, Monorepo, Polyrepo, Lerna, Nx, Turborepo, Bazel, Buck, Pants, Gradle, Maven, Ant, SBT, Cargo, Go Modules, Npm, Yarn, Pnpm, Bun, Deno, Composer, Pip, Poetry, Pipenv, Conda, Nuget, RubyGems, Hex, CocoaPods, Swift Package Manager.


And the list keeps growing...