System.register(["@angular/core","@angular/material/core","@angular/cdk/coercion","@angular/common","rxjs","rxjs/operators","@angular/common/http","@angular/platform-browser"],(function(t){"use strict";var e,n,o,i,s,r,a,c,l,h,u,g,f,m,d,_,p,v,I,S,C,E,F,w,R;return{setters:[function(t){e=t.SecurityContext,n=t,t.Injectable,o=t.Optional,t.Inject,i=t.SkipSelf,s=t.ErrorHandler,r=t.InjectionToken,a=t.inject,t.Component,t.ViewEncapsulation,t.ChangeDetectionStrategy,t.Attribute,t.Input,t.NgModule},function(t){c=t.mixinColor,l=t.MatCommonModule},function(t){h=t.coerceBooleanProperty},function(t){u=t.DOCUMENT},function(t){g=t.of,f=t.throwError,m=t.forkJoin,d=t.Subscription},function(t){_=t.tap,p=t.map,v=t.catchError,I=t.finalize,S=t.share,C=t.take},function(t){E=t,F=t.HttpClient},function(t){w=t,R=t.DomSanitizer}],execute:function(){t({ICON_REGISTRY_PROVIDER_FACTORY:L,MAT_ICON_LOCATION_FACTORY:D,getMatIconFailedToSanitizeLiteralError:b,getMatIconFailedToSanitizeUrlError:x,getMatIconNameNotFoundError:y,getMatIconNoHttpProviderError:A});const N=["*"];function y(t){return Error(`Unable to find icon with the name "${t}"`)}function A(){return Error("Could not find HttpClient provider for use with Angular Material icons. Please include the HttpClientModule from @angular/common/http in your app imports.")}function x(t){return Error(`The URL provided to MatIconRegistry was not trusted as a resource URL via Angular's DomSanitizer. Attempted URL was "${t}".`)}function b(t){return Error(`The literal provided to MatIconRegistry was not trusted as safe HTML by Angular's DomSanitizer. Attempted literal was "${t}".`)}class T{constructor(t,e,n){this.url=t,this.svgText=e,this.options=n}}class M{constructor(t,e,n,o){this._httpClient=t,this._sanitizer=e,this._errorHandler=o,this._svgIconConfigs=new Map,this._iconSetConfigs=new Map,this._cachedIconsByUrl=new Map,this._inProgressUrlFetches=new Map,this._fontCssClassesByAlias=new Map,this._resolvers=[],this._defaultFontSetClass=["material-icons","mat-ligature-font"],this._document=n}addSvgIcon(t,e,n){return this.addSvgIconInNamespace("",t,e,n)}addSvgIconLiteral(t,e,n){return this.addSvgIconLiteralInNamespace("",t,e,n)}addSvgIconInNamespace(t,e,n,o){return this._addSvgIconConfig(t,e,new T(n,null,o))}addSvgIconResolver(t){return this._resolvers.push(t),this}addSvgIconLiteralInNamespace(t,n,o,i){const s=this._sanitizer.sanitize(e.HTML,o);if(!s)throw b(o);const r=s;return this._addSvgIconConfig(t,n,new T("",r,i))}addSvgIconSet(t,e){return this.addSvgIconSetInNamespace("",t,e)}addSvgIconSetLiteral(t,e){return this.addSvgIconSetLiteralInNamespace("",t,e)}addSvgIconSetInNamespace(t,e,n){return this._addSvgIconSetConfig(t,new T(e,null,n))}addSvgIconSetLiteralInNamespace(t,n,o){const i=this._sanitizer.sanitize(e.HTML,n);if(!i)throw b(n);const s=i;return this._addSvgIconSetConfig(t,new T("",s,o))}registerFontClassAlias(t,e=t){return this._fontCssClassesByAlias.set(t,e),this}classNameForFontAlias(t){return this._fontCssClassesByAlias.get(t)||t}setDefaultFontSetClass(...t){return this._defaultFontSetClass=t,this}getDefaultFontSetClass(){return this._defaultFontSetClass}getSvgIconFromUrl(t){const n=this._sanitizer.sanitize(e.RESOURCE_URL,t);if(!n)throw x(t);const o=this._cachedIconsByUrl.get(n);return o?g(O(o)):this._loadSvgIconFromConfig(new T(t,null)).pipe(_((t=>this._cachedIconsByUrl.set(n,t))),p((t=>O(t))))}getNamedSvgIcon(t,e=""){const n=U(e,t);let o=this._svgIconConfigs.get(n);if(o)return this._getSvgFromConfig(o);if(o=this._getIconConfigFromResolvers(e,t),o)return this._svgIconConfigs.set(n,o),this._getSvgFromConfig(o);const i=this._iconSetConfigs.get(e);return i?this._getSvgFromIconSetConfigs(t,i):f(y(n))}ngOnDestroy(){this._resolvers=[],this._svgIconConfigs.clear(),this._iconSetConfigs.clear(),this._cachedIconsByUrl.clear()}_getSvgFromConfig(t){return t.svgText?g(O(this._svgElementFromConfig(t))):this._loadSvgIconFromConfig(t).pipe(p((t=>O(t))))}_getSvgFromIconSetConfigs(t,n){const o=this._extractIconWithNameFromAnySet(t,n);if(o)return g(o);const i=n.filter((t=>!t.svgText)).map((t=>this._loadSvgIconSetFromConfig(t).pipe(v((n=>{const o=`Loading icon set URL: ${this._sanitizer.sanitize(e.RESOURCE_URL,t.url)} failed: ${n.message}`;return this._errorHandler.handleError(new Error(o)),g(null)})))));return m(i).pipe(p((()=>{const e=this._extractIconWithNameFromAnySet(t,n);if(!e)throw y(t);return e})))}_extractIconWithNameFromAnySet(t,e){for(let n=e.length-1;n>=0;n--){const o=e[n];if(o.svgText&&o.svgText.toString().indexOf(t)>-1){const e=this._svgElementFromConfig(o),n=this._extractSvgIconFromSet(e,t,o.options);if(n)return n}}return null}_loadSvgIconFromConfig(t){return this._fetchIcon(t).pipe(_((e=>t.svgText=e)),p((()=>this._svgElementFromConfig(t))))}_loadSvgIconSetFromConfig(t){return t.svgText?g(null):this._fetchIcon(t).pipe(_((e=>t.svgText=e)))}_extractSvgIconFromSet(t,e,n){const o=t.querySelector(`[id="${e}"]`);if(!o)return null;const i=o.cloneNode(!0);if(i.removeAttribute("id"),"svg"===i.nodeName.toLowerCase())return this._setSvgAttributes(i,n);if("symbol"===i.nodeName.toLowerCase())return this._setSvgAttributes(this._toSvgElement(i),n);const s=this._svgElementFromString("");return s.appendChild(i),this._setSvgAttributes(s,n)}_svgElementFromString(t){const e=this._document.createElement("DIV");e.innerHTML=t;const n=e.querySelector("svg");if(!n)throw Error(" tag not found");return n}_toSvgElement(t){const e=this._svgElementFromString(""),n=t.attributes;for(let t=0;tt)),I((()=>this._inProgressUrlFetches.delete(s))),S());return this._inProgressUrlFetches.set(s,a),a}_addSvgIconConfig(t,e,n){return this._svgIconConfigs.set(U(t,e),n),this}_addSvgIconSetConfig(t,e){const n=this._iconSetConfigs.get(t);return n?n.push(e):this._iconSetConfigs.set(t,[e]),this}_svgElementFromConfig(t){if(!t.svgElement){const e=this._svgElementFromString(t.svgText);this._setSvgAttributes(e,t.options),t.svgElement=e}return t.svgElement}_getIconConfigFromResolvers(t,e){for(let o=0;oe?e.pathname+e.search:""}}const k=["clip-path","color-profile","src","cursor","fill","filter","marker","marker-start","marker-mid","marker-end","mask","stroke"],H=k.map((t=>`[${t}]`)).join(", "),$=/^url\(['"]?#(.*?)['"]?\)$/;class W extends j{get inline(){return this._inline}set inline(t){this._inline=h(t)}get svgIcon(){return this._svgIcon}set svgIcon(t){t!==this._svgIcon&&(t?this._updateSvgIcon(t):this._svgIcon&&this._clearSvgElement(),this._svgIcon=t)}get fontSet(){return this._fontSet}set fontSet(t){const e=this._cleanupFontValue(t);e!==this._fontSet&&(this._fontSet=e,this._updateFontIconClasses())}get fontIcon(){return this._fontIcon}set fontIcon(t){const e=this._cleanupFontValue(t);e!==this._fontIcon&&(this._fontIcon=e,this._updateFontIconClasses())}constructor(t,e,n,o,i,s){super(t),this._iconRegistry=e,this._location=o,this._errorHandler=i,this._inline=!1,this._previousFontSetClass=[],this._currentIconFetch=d.EMPTY,s&&(s.color&&(this.color=this.defaultColor=s.color),s.fontSet&&(this.fontSet=s.fontSet)),n||t.nativeElement.setAttribute("aria-hidden","true")}_splitIconName(t){if(!t)return["",""];const e=t.split(":");switch(e.length){case 1:return["",e[0]];case 2:return e;default:throw Error(`Invalid icon name: "${t}"`)}}ngOnInit(){this._updateFontIconClasses()}ngAfterViewChecked(){const t=this._elementsWithExternalReferences;if(t&&t.size){const t=this._location.getPathname();t!==this._previousPath&&(this._previousPath=t,this._prependPathToReferences(t))}}ngOnDestroy(){this._currentIconFetch.unsubscribe(),this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear()}_usingFontIcon(){return!this.svgIcon}_setSvgElement(t){this._clearSvgElement();const e=this._location.getPathname();this._previousPath=e,this._cacheChildrenWithExternalReferences(t),this._prependPathToReferences(e),this._elementRef.nativeElement.appendChild(t)}_clearSvgElement(){const t=this._elementRef.nativeElement;let e=t.childNodes.length;for(this._elementsWithExternalReferences&&this._elementsWithExternalReferences.clear();e--;){const n=t.childNodes[e];1===n.nodeType&&"svg"!==n.nodeName.toLowerCase()||n.remove()}}_updateFontIconClasses(){if(!this._usingFontIcon())return;const t=this._elementRef.nativeElement,e=(this.fontSet?this._iconRegistry.classNameForFontAlias(this.fontSet).split(/ +/):this._iconRegistry.getDefaultFontSetClass()).filter((t=>t.length>0));this._previousFontSetClass.forEach((e=>t.classList.remove(e))),e.forEach((e=>t.classList.add(e))),this._previousFontSetClass=e,this.fontIcon===this._previousFontIconClass||e.includes("mat-ligature-font")||(this._previousFontIconClass&&t.classList.remove(this._previousFontIconClass),this.fontIcon&&t.classList.add(this.fontIcon),this._previousFontIconClass=this.fontIcon)}_cleanupFontValue(t){return"string"==typeof t?t.trim().split(" ")[0]:t}_prependPathToReferences(t){const e=this._elementsWithExternalReferences;e&&e.forEach(((e,n)=>{e.forEach((e=>{n.setAttribute(e.name,`url('${t}#${e.value}')`)}))}))}_cacheChildrenWithExternalReferences(t){const e=t.querySelectorAll(H),n=this._elementsWithExternalReferences=this._elementsWithExternalReferences||new Map;for(let t=0;t{const i=e[t],s=i.getAttribute(o),r=s?s.match($):null;if(r){let t=n.get(i);t||(t=[],n.set(i,t)),t.push({name:o,value:r[1]})}}))}_updateSvgIcon(t){if(this._svgNamespace=null,this._svgName=null,this._currentIconFetch.unsubscribe(),t){const[e,n]=this._splitIconName(t);e&&(this._svgNamespace=e),n&&(this._svgName=n),this._currentIconFetch=this._iconRegistry.getNamedSvgIcon(n,e).pipe(C(1)).subscribe((t=>this._setSvgElement(t)),(t=>{const o=`Error retrieving icon ${e}:${n}! ${t.message}`;this._errorHandler.handleError(new Error(o))}))}}static{this.\u0275fac=function(t){return new(t||W)(n.\u0275\u0275directiveInject(n.ElementRef),n.\u0275\u0275directiveInject(M),n.\u0275\u0275injectAttribute("aria-hidden"),n.\u0275\u0275directiveInject(z),n.\u0275\u0275directiveInject(n.ErrorHandler),n.\u0275\u0275directiveInject(P,8))}}static{this.\u0275cmp=n.\u0275\u0275defineComponent({type:W,selectors:[["mat-icon"]],hostAttrs:["role","img",1,"mat-icon","notranslate"],hostVars:8,hostBindings:function(t,e){2&t&&(n.\u0275\u0275attribute("data-mat-icon-type",e._usingFontIcon()?"font":"svg")("data-mat-icon-name",e._svgName||e.fontIcon)("data-mat-icon-namespace",e._svgNamespace||e.fontSet)("fontIcon",e._usingFontIcon()?e.fontIcon:null),n.\u0275\u0275classProp("mat-icon-inline",e.inline)("mat-icon-no-color","primary"!==e.color&&"accent"!==e.color&&"warn"!==e.color))},inputs:{color:"color",inline:"inline",svgIcon:"svgIcon",fontSet:"fontSet",fontIcon:"fontIcon"},exportAs:["matIcon"],features:[n.\u0275\u0275InheritDefinitionFeature],ngContentSelectors:N,decls:1,vars:0,template:function(t,e){1&t&&(n.\u0275\u0275projectionDef(),n.\u0275\u0275projection(0))},styles:["mat-icon,mat-icon.mat-primary,mat-icon.mat-accent,mat-icon.mat-warn{color:var(--mat-icon-color)}.mat-icon{-webkit-user-select:none;user-select:none;background-repeat:no-repeat;display:inline-block;fill:currentColor;height:24px;width:24px;overflow:hidden}.mat-icon.mat-icon-inline{font-size:inherit;height:inherit;line-height:inherit;width:inherit}.mat-icon.mat-ligature-font[fontIcon]::before{content:attr(fontIcon)}[dir=rtl] .mat-icon-rtl-mirror{transform:scale(-1, 1)}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon{display:block}.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-prefix .mat-icon-button .mat-icon,.mat-form-field:not(.mat-form-field-appearance-legacy) .mat-form-field-suffix .mat-icon-button .mat-icon{margin:auto}"],encapsulation:2,changeDetection:0})}}t("MatIcon",W);class B{static{this.\u0275fac=function(t){return new(t||B)}}static{this.\u0275mod=n.\u0275\u0275defineNgModule({type:B})}static{this.\u0275inj=n.\u0275\u0275defineInjector({imports:[l,l]})}}t("MatIconModule",B)}}})); HR News – Gavin Mostert Attorneys https://gavinmostert.co.za Providing Quality Legal Services At Reasonable Prices Wed, 23 Sep 2026 19:30:14 +0000 en-US hourly 1 https://gavinmostert.co.za/wp-content/uploads/2020/10/cropped-Gavin-Mostert-Attorney-Edenvale-Logo-a8f9cd-32x32.jpg HR News – Gavin Mostert Attorneys https://gavinmostert.co.za 32 32 How AI Is Reshaping The Human Resources Profession https://gavinmostert.co.za/how-ai-is-reshaping-the-human-resources-profession-3/ https://gavinmostert.co.za/how-ai-is-reshaping-the-human-resources-profession-3/#respond admin Wed, 20 Oct 2021 11:21:07 +0000 HR News https://gavinmostert.co.za/?p=21936 An aspiring product manager, for instance, might use roleplaying to practice giving feedback https://www.storymen.us/my-most-valuable-advice-3/ or communicating with picky clients. It helps employees plan their careers and focus on the skills that interest them. It&#8217;s also useful for executives who need support managing their time or leading change. In many HR processes, the best approach is [&#8230;] <p><img decoding="async" class='wp-post-image' style='display: block;margin-left:auto;margin-right:auto;' src="data:image/png;base64,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" width="250px" alt="AI in HR"/></p> <p><p>An aspiring product manager, for instance, might use roleplaying to practice giving feedback <a href="https://www.storymen.us/my-most-valuable-advice-3/">https://www.storymen.us/my-most-valuable-advice-3/</a> or communicating with picky clients. It helps employees plan their careers and focus on the skills that interest them. It&#8217;s also useful for executives who need support managing their time or leading change.</p> </p> <p><p>In many HR processes, the best approach is “AI prepares, humans decide.” Let AI summarize, categorize, and flag potential issues, then have HR and leaders validate the context, check for fairness, and make the call. Culture and leadership work also stays human, because coaching managers, navigating change, and building trust rely on relationships and credibility, not just data. This typically includes scheduling and coordination (interview scheduling, reminders, follow-ups), routing work (ticket triage, assigning cases to the right HR specialist), and workflow automation for onboarding and offboarding. When the stakes and human impact are high, keep humans accountable and use AI as support. AI enhances decision-making, but HR remains critical in ensuring that strategies are people-centered and aligned with organizational goals.</p> </p> <p><img decoding="async" class='aligncenter' style='display: block;margin-left:auto;margin-right:auto;' src="data:image/png;base64,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" width="255px" alt="AI in HR"/></p> <p><p>AI technology poses direct risks that stem from how it works, its capabilities, and its limitations. Perplexity is an AI-powered search and answer engine designed to provide cited, real-time answers to complex queries. While ChatGPT is currently the most widely used generative AI tool, it’s far from the only option available.</p> </p> <p><h2>AI Applications Across HR Functions</h2> </p> <p><p>ChatGPT comes in handy for teams that spend a lot of time generating content. Fetcher is useful for teams that struggle to recruit experts, but you may not need it if you already have a steady stream of applicants. It integrates with ATS and candidate relationship management (CRM) software to help you source top candidates. That way, you can start building relationships early instead of scrambling to fill roles. Starts at $379 per month, with enterprise pricing available for high-volume teams</p> </p> <p><img decoding="async" class='aligncenter' style='display: block;margin-left:auto;margin-right:auto;' src="data:image/jpeg;base64,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" width="250px" alt="AI in HR"/></p> <ul> <li>From analyzing workforce data trends to improving talent management and employee development, AI is helping HR teams work more efficiently while enhancing the employee experience.</li> <li>Fetcher is useful for teams that struggle to recruit experts, but you may not need it if you already have a steady stream of applicants.</li> <li>Qualified candidates reaching phone screen increased 40%.</li> <li>Like AI agents, they maintain memory, storing user preferences and past interactions.</li> <li>In the future, HR will also need to manage co-bots working alongside employees to get work done.</li> </ul> <p><p>For example, if your support <a href="https://the-business-mag.net/what-legal-mistakes-should-startups-avoid/">https://the-business-mag.net/what-legal-mistakes-should-startups-avoid/</a> team is overwhelmed by tickets, an AI agent can help lighten their workload. Resist the urge to go all-in with your new HR software right off the bat, especially if your team isn&#8217;t used to this technology. However, it doesn&#8217;t provide any support once you actually hire them, so you&#8217;ll need additional HR tools for onboarding and beyond. These messages can help you connect with top candidates and pique their interest in your roles.</p> </p> <p><h2>How HR departments are using AI</h2> </p> <p><p>Lattice is useful for managers wanting to provide more detailed and timely feedback, but costs can add up quickly as your team grows. Leena.ai works best for enterprises and global organizations that need <a href="https://genericialisonlinefg.com/hr-strategy-consulting-for-modern-workforces/">https://genericialisonlinefg.com/hr-strategy-consulting-for-modern-workforces/</a> 24/7 support. These AI assistants talk directly with employees and provide immediate support. Most HR teams deal with a constant barrage of questions and requests from employees.</p> </p> <p><p>HR teams can use it for fast, reliable research, whether it’s comparing global HR policies, summarizing academic insights, or finding benchmark data, without having to dig through multiple sources manually. AI-based coaching is a technology-assisted coaching process that uses artificial intelligence to provide personalized feedback, guidance, and development support to employees. These findings provide actionable direction, empowering you to make informed, strategic decisions as you guide your organization and workforce forward. Drawing on insights from 1,908 HR professionals, the report reveals which HR functions are most shaped by AI, identifies persistent challenges to adoption, and details the steps organizations are taking to set policy and ensure compliance.</p> </p> <p><div style='text-align:center'><iframe width='561' height='317' src='https://www.youtube.com/embed/_RztYjzmNWc' frameborder='0' alt='AI in HR' allowfullscreen></iframe></div> </p> <p><p>HR will need to become the gatekeepers for the responsible use of AI across the organization, now and in the future. New, broader roles will emerge that combine business knowledge and technological expertise. In the future, HR will also need to manage co-bots working alongside employees to get work done. The future of AI in HR not only holds significant promise, but also inevitable transformation within the HR profession.</p> </p> <p><h2>HR chatbots and copilots</h2> </p> <p><p>The first two parts—internal and external environment—focus on organizational internal and external risks. Some AI systems lack transparency regarding decision-making, which can lead to a lack of trust between candidates, employees, and HR, and decisions become hard to justify in legal contexts. These include bias and fairness risks if the technology has been trained on biased data.</p></p> https://gavinmostert.co.za/how-ai-is-reshaping-the-human-resources-profession-3/feed/ 0